diff options
119 files changed, 2612 insertions, 554 deletions
diff --git a/core/core_bind.cpp b/core/core_bind.cpp index c93a9c945f..706395afa9 100644 --- a/core/core_bind.cpp +++ b/core/core_bind.cpp @@ -2291,6 +2291,18 @@ Vector<String> Engine::get_singleton_list() const { return ret; } +void Engine::register_script_language(ScriptLanguage *p_language) { + ScriptServer::register_language(p_language); +} + +int Engine::get_script_language_count() { + return ScriptServer::get_language_count(); +} + +ScriptLanguage *Engine::get_script_language(int p_index) const { + return ScriptServer::get_language(p_index); +} + void Engine::set_editor_hint(bool p_enabled) { ::Engine::get_singleton()->set_editor_hint(p_enabled); } @@ -2342,6 +2354,10 @@ void Engine::_bind_methods() { ClassDB::bind_method(D_METHOD("unregister_singleton", "name"), &Engine::unregister_singleton); ClassDB::bind_method(D_METHOD("get_singleton_list"), &Engine::get_singleton_list); + ClassDB::bind_method(D_METHOD("register_script_language", "language"), &Engine::register_script_language); + ClassDB::bind_method(D_METHOD("get_script_language_count"), &Engine::get_script_language_count); + ClassDB::bind_method(D_METHOD("get_script_language", "index"), &Engine::get_script_language); + ClassDB::bind_method(D_METHOD("is_editor_hint"), &Engine::is_editor_hint); ClassDB::bind_method(D_METHOD("set_print_error_messages", "enabled"), &Engine::set_print_error_messages); diff --git a/core/core_bind.h b/core/core_bind.h index 11a1220277..907f37c5fa 100644 --- a/core/core_bind.h +++ b/core/core_bind.h @@ -38,6 +38,7 @@ #include "core/io/image.h" #include "core/io/resource_loader.h" #include "core/io/resource_saver.h" +#include "core/object/script_language.h" #include "core/os/os.h" #include "core/os/semaphore.h" #include "core/os/thread.h" @@ -663,6 +664,10 @@ public: void unregister_singleton(const StringName &p_name); Vector<String> get_singleton_list() const; + void register_script_language(ScriptLanguage *p_language); + int get_script_language_count(); + ScriptLanguage *get_script_language(int p_index) const; + void set_editor_hint(bool p_enabled); bool is_editor_hint() const; diff --git a/core/extension/SCsub b/core/extension/SCsub index a3a54250c1..23727c1b76 100644 --- a/core/extension/SCsub +++ b/core/extension/SCsub @@ -2,6 +2,12 @@ Import("env") +import make_wrappers +from platform_methods import run_in_subprocess + +env.CommandNoCache(["ext_wrappers.gen.inc"], "make_wrappers.py", run_in_subprocess(make_wrappers.run)) + + env_extension = env.Clone() env_extension.add_source_files(env.core_sources, "*.cpp") diff --git a/core/extension/gdnative_interface.cpp b/core/extension/gdnative_interface.cpp index d0461611ec..b5b340731d 100644 --- a/core/extension/gdnative_interface.cpp +++ b/core/extension/gdnative_interface.cpp @@ -32,6 +32,7 @@ #include "core/config/engine.h" #include "core/object/class_db.h" +#include "core/object/script_language_extension.h" #include "core/os/memory.h" #include "core/variant/variant.h" #include "core/version.h" @@ -864,6 +865,13 @@ static GDObjectInstanceID gdnative_object_get_instance_id(const GDNativeObjectPt return (GDObjectInstanceID)o->get_instance_id(); } +static GDNativeScriptInstancePtr gdnative_script_instance_create(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data) { + ScriptInstanceExtension *script_instance_extension = memnew(ScriptInstanceExtension); + script_instance_extension->instance = p_instance_data; + script_instance_extension->native_info = p_info; + return reinterpret_cast<GDNativeScriptInstancePtr>(script_instance_extension); +} + static GDNativeMethodBindPtr gdnative_classdb_get_method_bind(const char *p_classname, const char *p_methodname, GDNativeInt p_hash) { MethodBind *mb = ClassDB::get_method(StringName(p_classname), StringName(p_methodname)); ERR_FAIL_COND_V(!mb, nullptr); @@ -1032,6 +1040,10 @@ void gdnative_setup_interface(GDNativeInterface *p_interface) { gdni.object_get_instance_from_id = gdnative_object_get_instance_from_id; gdni.object_get_instance_id = gdnative_object_get_instance_id; + /* SCRIPT INSTANCE */ + + gdni.script_instance_create = gdnative_script_instance_create; + /* CLASSDB */ gdni.classdb_construct_object = gdnative_classdb_construct_object; diff --git a/core/extension/gdnative_interface.h b/core/extension/gdnative_interface.h index cc2957ec56..732a1b5af0 100644 --- a/core/extension/gdnative_interface.h +++ b/core/extension/gdnative_interface.h @@ -205,10 +205,21 @@ typedef struct { uint32_t usage; } GDNativePropertyInfo; +typedef struct { + const char *name; + GDNativePropertyInfo return_value; + uint32_t flags; // From GDNativeExtensionClassMethodFlags + int32_t id; + GDNativePropertyInfo *arguments; + uint32_t argument_count; + GDNativeVariantPtr default_arguments; + uint32_t default_argument_count; +} GDNativeMethodInfo; + typedef const GDNativePropertyInfo *(*GDNativeExtensionClassGetPropertyList)(GDExtensionClassInstancePtr p_instance, uint32_t *r_count); typedef void (*GDNativeExtensionClassFreePropertyList)(GDExtensionClassInstancePtr p_instance, const GDNativePropertyInfo *p_list); typedef void (*GDNativeExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what); -typedef const char *(*GDNativeExtensionClassToString)(GDExtensionClassInstancePtr p_instance); +typedef void (*GDNativeExtensionClassToString)(GDExtensionClassInstancePtr p_instance, GDNativeStringPtr p_out); typedef void (*GDNativeExtensionClassReference)(GDExtensionClassInstancePtr p_instance); typedef void (*GDNativeExtensionClassUnreference)(GDExtensionClassInstancePtr p_instance); typedef void (*GDNativeExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret); @@ -289,6 +300,79 @@ typedef struct { GDNativeVariantPtr *default_arguments; } GDNativeExtensionClassMethodInfo; +/* SCRIPT INSTANCE EXTENSION */ + +typedef void *GDNativeExtensionScriptInstanceDataPtr; // Pointer to custom ScriptInstance native implementation + +typedef GDNativeBool (*GDNativeExtensionScriptInstanceSet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value); +typedef GDNativeBool (*GDNativeExtensionScriptInstanceGet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret); +typedef const GDNativePropertyInfo *(*GDNativeExtensionScriptInstanceGetPropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count); +typedef void (*GDNativeExtensionScriptInstanceFreePropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativePropertyInfo *p_list); +typedef GDNativeVariantType (*GDNativeExtensionScriptInstanceGetPropertyType)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeBool *r_is_valid); + +typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetOwner)(GDNativeExtensionScriptInstanceDataPtr p_instance); +typedef void (*GDNativeExtensionScriptInstancePropertyStateAdd)(const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value, void *p_userdata); +typedef void (*GDNativeExtensionScriptInstanceGetPropertyState)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeExtensionScriptInstancePropertyStateAdd p_add_func, void *p_userdata); + +typedef const GDNativeMethodInfo *(*GDNativeExtensionScriptInstanceGetMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count); +typedef void (*GDNativeExtensionScriptInstanceFreeMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeMethodInfo *p_list); + +typedef GDNativeBool (*GDNativeExtensionScriptInstanceHasMethod)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name); + +typedef void (*GDNativeExtensionScriptInstanceCall)(GDNativeExtensionScriptInstanceDataPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error); +typedef void (*GDNativeExtensionScriptInstanceNotification)(GDNativeExtensionScriptInstanceDataPtr p_instance, int32_t p_what); +typedef const char *(*GDNativeExtensionScriptInstanceToString)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeBool *r_is_valid); + +typedef void (*GDNativeExtensionScriptInstanceRefCountIncremented)(GDNativeExtensionScriptInstanceDataPtr p_instance); +typedef GDNativeBool (*GDNativeExtensionScriptInstanceRefCountDecremented)(GDNativeExtensionScriptInstanceDataPtr p_instance); + +typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetScript)(GDNativeExtensionScriptInstanceDataPtr p_instance); +typedef GDNativeBool (*GDNativeExtensionScriptInstanceIsPlaceholder)(GDNativeExtensionScriptInstanceDataPtr p_instance); + +typedef void *GDNativeExtensionScriptLanguagePtr; + +typedef GDNativeExtensionScriptLanguagePtr (*GDNativeExtensionScriptInstanceGetLanguage)(GDNativeExtensionScriptInstanceDataPtr p_instance); + +typedef void (*GDNativeExtensionScriptInstanceFree)(GDNativeExtensionScriptInstanceDataPtr p_instance); + +typedef void *GDNativeScriptInstancePtr; // Pointer to ScriptInstance. + +typedef struct { + GDNativeExtensionScriptInstanceSet set_func; + GDNativeExtensionScriptInstanceGet get_func; + GDNativeExtensionScriptInstanceGetPropertyList get_property_list_func; + GDNativeExtensionScriptInstanceFreePropertyList free_property_list_func; + GDNativeExtensionScriptInstanceGetPropertyType get_property_type_func; + + GDNativeExtensionScriptInstanceGetOwner get_owner_func; + GDNativeExtensionScriptInstanceGetPropertyState get_property_state_func; + + GDNativeExtensionScriptInstanceGetMethodList get_method_list_func; + GDNativeExtensionScriptInstanceFreeMethodList free_method_list_func; + + GDNativeExtensionScriptInstanceHasMethod has_method_func; + + GDNativeExtensionScriptInstanceCall call_func; + GDNativeExtensionScriptInstanceNotification notification_func; + + GDNativeExtensionScriptInstanceToString to_string_func; + + GDNativeExtensionScriptInstanceRefCountIncremented refcount_incremented_func; + GDNativeExtensionScriptInstanceRefCountDecremented refcount_decremented_func; + + GDNativeExtensionScriptInstanceGetScript get_script_func; + + GDNativeExtensionScriptInstanceIsPlaceholder is_placeholder_func; + + GDNativeExtensionScriptInstanceSet set_fallback_func; + GDNativeExtensionScriptInstanceGet get_fallback_func; + + GDNativeExtensionScriptInstanceGetLanguage get_language_func; + + GDNativeExtensionScriptInstanceFree free_func; + +} GDNativeExtensionScriptInstanceInfo; + /* INTERFACE */ typedef struct { @@ -441,6 +525,10 @@ typedef struct { GDNativeObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id); GDObjectInstanceID (*object_get_instance_id)(const GDNativeObjectPtr p_object); + /* SCRIPT INSTANCE */ + + GDNativeScriptInstancePtr (*script_instance_create)(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data); + /* CLASSDB */ GDNativeObjectPtr (*classdb_construct_object)(const char *p_classname); /* The passed class must be a built-in godot class, or an already-registered extension class. In both case, object_set_instance should be called to fully initialize the object. */ GDNativeMethodBindPtr (*classdb_get_method_bind)(const char *p_classname, const char *p_methodname, GDNativeInt p_hash); diff --git a/servers/extensions/make_wrappers.py b/core/extension/make_wrappers.py index 862d313fba..862d313fba 100644 --- a/servers/extensions/make_wrappers.py +++ b/core/extension/make_wrappers.py diff --git a/core/input/input.cpp b/core/input/input.cpp index 656bb92203..e64b5a3ab7 100644 --- a/core/input/input.cpp +++ b/core/input/input.cpp @@ -72,7 +72,7 @@ Input *Input::singleton = nullptr; void (*Input::set_mouse_mode_func)(Input::MouseMode) = nullptr; Input::MouseMode (*Input::get_mouse_mode_func)() = nullptr; -void (*Input::warp_mouse_func)(const Vector2 &p_to_pos) = nullptr; +void (*Input::warp_mouse_func)(const Vector2 &p_position) = nullptr; Input::CursorShape (*Input::get_current_cursor_shape_func)() = nullptr; void (*Input::set_custom_mouse_cursor_func)(const RES &, Input::CursorShape, const Vector2 &) = nullptr; @@ -126,7 +126,7 @@ void Input::_bind_methods() { ClassDB::bind_method(D_METHOD("get_mouse_button_mask"), &Input::get_mouse_button_mask); ClassDB::bind_method(D_METHOD("set_mouse_mode", "mode"), &Input::set_mouse_mode); ClassDB::bind_method(D_METHOD("get_mouse_mode"), &Input::get_mouse_mode); - ClassDB::bind_method(D_METHOD("warp_mouse_position", "to"), &Input::warp_mouse_position); + ClassDB::bind_method(D_METHOD("warp_mouse", "position"), &Input::warp_mouse); ClassDB::bind_method(D_METHOD("action_press", "action", "strength"), &Input::action_press, DEFVAL(1.f)); ClassDB::bind_method(D_METHOD("action_release", "action"), &Input::action_release); ClassDB::bind_method(D_METHOD("set_default_cursor_shape", "shape"), &Input::set_default_cursor_shape, DEFVAL(CURSOR_ARROW)); @@ -733,8 +733,8 @@ MouseButton Input::get_mouse_button_mask() const { return mouse_button_mask; // do not trust OS implementation, should remove it - OS::get_singleton()->get_mouse_button_state(); } -void Input::warp_mouse_position(const Vector2 &p_to) { - warp_mouse_func(p_to); +void Input::warp_mouse(const Vector2 &p_position) { + warp_mouse_func(p_position); } Point2i Input::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) { @@ -756,7 +756,7 @@ Point2i Input::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, con const Point2i pos_local = p_motion->get_global_position() - p_rect.position; const Point2i pos_warped(Math::fposmod(pos_local.x, p_rect.size.x), Math::fposmod(pos_local.y, p_rect.size.y)); if (pos_warped != pos_local) { - warp_mouse_position(pos_warped + p_rect.position); + warp_mouse(pos_warped + p_rect.position); } return rel_warped; diff --git a/core/input/input.h b/core/input/input.h index ab2cd377f4..ac688b53b8 100644 --- a/core/input/input.h +++ b/core/input/input.h @@ -216,7 +216,7 @@ private: static void (*set_mouse_mode_func)(MouseMode); static MouseMode (*get_mouse_mode_func)(); - static void (*warp_mouse_func)(const Vector2 &p_to_pos); + static void (*warp_mouse_func)(const Vector2 &p_position); static CursorShape (*get_current_cursor_shape_func)(); static void (*set_custom_mouse_cursor_func)(const RES &, CursorShape, const Vector2 &); @@ -273,7 +273,7 @@ public: Vector2 get_last_mouse_velocity(); MouseButton get_mouse_button_mask() const; - void warp_mouse_position(const Vector2 &p_to); + void warp_mouse(const Vector2 &p_position); Point2i warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect); void parse_input_event(const Ref<InputEvent> &p_event); diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp index 4f1901c70b..fd86a02b90 100644 --- a/core/object/class_db.cpp +++ b/core/object/class_db.cpp @@ -1485,9 +1485,10 @@ void ClassDB::add_virtual_method(const StringName &p_class, const MethodInfo &p_ if (p_object_core) { mi.flags |= METHOD_FLAG_OBJECT_CORE; } - if (p_arg_names.size()) { + + if (!p_object_core) { if (p_arg_names.size() != mi.arguments.size()) { - WARN_PRINT("Mismatch argument name count for virtual function: " + String(p_class) + "::" + p_method.name); + WARN_PRINT("Mismatch argument name count for virtual method: " + String(p_class) + "::" + p_method.name); } else { for (int i = 0; i < p_arg_names.size(); i++) { mi.arguments[i].name = p_arg_names[i]; @@ -1495,6 +1496,10 @@ void ClassDB::add_virtual_method(const StringName &p_class, const MethodInfo &p_ } } + if (classes[p_class].virtual_methods_map.has(p_method.name)) { + // overloading not supported + ERR_FAIL_MSG("Virtual method already bound '" + String(p_class) + "::" + p_method.name + "'."); + } classes[p_class].virtual_methods.push_back(mi); classes[p_class].virtual_methods_map[p_method.name] = mi; diff --git a/core/object/object.cpp b/core/object/object.cpp index 226d3ef0b8..7db62fdc5c 100644 --- a/core/object/object.cpp +++ b/core/object/object.cpp @@ -865,7 +865,9 @@ String Object::to_string() { } } if (_extension && _extension->to_string) { - return _extension->to_string(_extension_instance); + String ret; + _extension->to_string(_extension_instance, &ret); + return ret; } return "[" + get_class() + ":" + itos(get_instance_id()) + "]"; } diff --git a/core/object/script_language.h b/core/object/script_language.h index 2122f785b6..6161a0fc0f 100644 --- a/core/object/script_language.h +++ b/core/object/script_language.h @@ -132,7 +132,7 @@ public: virtual Error reload(bool p_keep_state = false) = 0; #ifdef TOOLS_ENABLED - virtual const Vector<DocData::ClassDoc> &get_documentation() const = 0; + virtual Vector<DocData::ClassDoc> get_documentation() const = 0; #endif // TOOLS_ENABLED virtual bool has_method(const StringName &p_method) const = 0; @@ -212,44 +212,12 @@ public: virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid); virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid); - virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const = 0; + virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const { return get_script()->get_rpc_methods(); } virtual ScriptLanguage *get_language() = 0; virtual ~ScriptInstance(); }; -struct ScriptCodeCompletionOption { - /* Keep enum in Sync with: */ - /* /scene/gui/code_edit.h - CodeEdit::CodeCompletionKind */ - enum Kind { - KIND_CLASS, - KIND_FUNCTION, - KIND_SIGNAL, - KIND_VARIABLE, - KIND_MEMBER, - KIND_ENUM, - KIND_CONSTANT, - KIND_NODE_PATH, - KIND_FILE_PATH, - KIND_PLAIN_TEXT, - }; - Kind kind = KIND_PLAIN_TEXT; - String display; - String insert_text; - Color font_color; - RES icon; - Variant default_value; - Vector<Pair<int, int>> matches; - - ScriptCodeCompletionOption() {} - - ScriptCodeCompletionOption(const String &p_text, Kind p_kind) { - display = p_text; - insert_text = p_text; - kind = p_kind; - } -}; - class ScriptCodeCompletionCache { static ScriptCodeCompletionCache *singleton; @@ -261,7 +229,8 @@ public: virtual ~ScriptCodeCompletionCache() {} }; -class ScriptLanguage { +class ScriptLanguage : public Object { + GDCLASS(ScriptLanguage, Object) public: virtual String get_name() const = 0; @@ -326,19 +295,55 @@ public: virtual Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) { return ERR_UNAVAILABLE; } virtual bool overrides_external_editor() { return false; } - virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; } + /* Keep enum in Sync with: */ + /* /scene/gui/code_edit.h - CodeEdit::CodeCompletionKind */ + enum CodeCompletionKind { + CODE_COMPLETION_KIND_CLASS, + CODE_COMPLETION_KIND_FUNCTION, + CODE_COMPLETION_KIND_SIGNAL, + CODE_COMPLETION_KIND_VARIABLE, + CODE_COMPLETION_KIND_MEMBER, + CODE_COMPLETION_KIND_ENUM, + CODE_COMPLETION_KIND_CONSTANT, + CODE_COMPLETION_KIND_NODE_PATH, + CODE_COMPLETION_KIND_FILE_PATH, + CODE_COMPLETION_KIND_PLAIN_TEXT, + CODE_COMPLETION_KIND_MAX + }; + + struct CodeCompletionOption { + CodeCompletionKind kind = CODE_COMPLETION_KIND_PLAIN_TEXT; + String display; + String insert_text; + Color font_color; + RES icon; + Variant default_value; + Vector<Pair<int, int>> matches; + + CodeCompletionOption() {} + + CodeCompletionOption(const String &p_text, CodeCompletionKind p_kind) { + display = p_text; + insert_text = p_text; + kind = p_kind; + } + }; + + virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; } + + enum LookupResultType { + LOOKUP_RESULT_SCRIPT_LOCATION, + LOOKUP_RESULT_CLASS, + LOOKUP_RESULT_CLASS_CONSTANT, + LOOKUP_RESULT_CLASS_PROPERTY, + LOOKUP_RESULT_CLASS_METHOD, + LOOKUP_RESULT_CLASS_ENUM, + LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE, + LOOKUP_RESULT_MAX + }; struct LookupResult { - enum Type { - RESULT_SCRIPT_LOCATION, - RESULT_CLASS, - RESULT_CLASS_CONSTANT, - RESULT_CLASS_PROPERTY, - RESULT_CLASS_METHOD, - RESULT_CLASS_ENUM, - RESULT_CLASS_TBD_GLOBALSCOPE - }; - Type type; + LookupResultType type; Ref<Script> script; String class_name; String class_member; diff --git a/core/object/script_language_extension.cpp b/core/object/script_language_extension.cpp new file mode 100644 index 0000000000..bf0966c803 --- /dev/null +++ b/core/object/script_language_extension.cpp @@ -0,0 +1,175 @@ +/*************************************************************************/ +/* script_language_extension.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "script_language_extension.h" + +void ScriptExtension::_bind_methods() { + GDVIRTUAL_BIND(_editor_can_reload_from_file); + GDVIRTUAL_BIND(_placeholder_erased, "placeholder"); + + GDVIRTUAL_BIND(_can_instantiate); + GDVIRTUAL_BIND(_get_base_script); + GDVIRTUAL_BIND(_inherits_script, "script"); + + GDVIRTUAL_BIND(_get_instance_base_type); + GDVIRTUAL_BIND(_instance_create, "for_object"); + GDVIRTUAL_BIND(_placeholder_instance_create, "for_object"); + + GDVIRTUAL_BIND(_instance_has, "object"); + + GDVIRTUAL_BIND(_has_source_code); + GDVIRTUAL_BIND(_get_source_code); + + GDVIRTUAL_BIND(_set_source_code, "code"); + GDVIRTUAL_BIND(_reload, "keep_state"); + + GDVIRTUAL_BIND(_get_documentation); + + GDVIRTUAL_BIND(_has_method, "method"); + GDVIRTUAL_BIND(_get_method_info, "method"); + + GDVIRTUAL_BIND(_is_tool); + GDVIRTUAL_BIND(_is_valid); + GDVIRTUAL_BIND(_get_language); + + GDVIRTUAL_BIND(_has_script_signal, "signal"); + GDVIRTUAL_BIND(_get_script_signal_list); + + GDVIRTUAL_BIND(_get_property_default_value, "property"); + + GDVIRTUAL_BIND(_update_exports); + GDVIRTUAL_BIND(_get_script_method_list); + GDVIRTUAL_BIND(_get_script_property_list); + + GDVIRTUAL_BIND(_get_member_line, "member"); + + GDVIRTUAL_BIND(_get_constants); + GDVIRTUAL_BIND(_get_members); + GDVIRTUAL_BIND(_is_placeholder_fallback_enabled); + + GDVIRTUAL_BIND(_get_rpc_methods); +} + +void ScriptLanguageExtension::_bind_methods() { + GDVIRTUAL_BIND(_get_name); + GDVIRTUAL_BIND(_init); + GDVIRTUAL_BIND(_get_type); + GDVIRTUAL_BIND(_get_extension); + GDVIRTUAL_BIND(_execute_file, "path"); + GDVIRTUAL_BIND(_finish); + + GDVIRTUAL_BIND(_get_reserved_words); + GDVIRTUAL_BIND(_is_control_flow_keyword, "keyword"); + GDVIRTUAL_BIND(_get_comment_delimiters); + GDVIRTUAL_BIND(_get_string_delimiters); + GDVIRTUAL_BIND(_make_template, "template", "class_name", "base_class_name"); + GDVIRTUAL_BIND(_get_built_in_templates, "object"); + GDVIRTUAL_BIND(_is_using_templates); + GDVIRTUAL_BIND(_validate, "script", "path", "validate_functions", "validate_errors", "validate_warnings", "validate_safe_lines"); + + GDVIRTUAL_BIND(_validate_path, "path"); + GDVIRTUAL_BIND(_create_script); + GDVIRTUAL_BIND(_has_named_classes); + GDVIRTUAL_BIND(_supports_builtin_mode); + GDVIRTUAL_BIND(_supports_documentation); + GDVIRTUAL_BIND(_can_inherit_from_file); + GDVIRTUAL_BIND(_find_function, "class_name", "function_name"); + GDVIRTUAL_BIND(_make_function, "class_name", "function_name", "function_args"); + GDVIRTUAL_BIND(_open_in_external_editor, "script", "line", "column"); + GDVIRTUAL_BIND(_overrides_external_editor); + + GDVIRTUAL_BIND(_complete_code, "code", "path", "owner"); + GDVIRTUAL_BIND(_lookup_code, "code", "symbol", "path", "owner"); + GDVIRTUAL_BIND(_auto_indent_code, "code", "from_line", "to_line"); + + GDVIRTUAL_BIND(_add_global_constant, "name", "value"); + GDVIRTUAL_BIND(_add_named_global_constant, "name", "value"); + GDVIRTUAL_BIND(_remove_named_global_constant, "name"); + + GDVIRTUAL_BIND(_thread_enter); + GDVIRTUAL_BIND(_thread_exit); + GDVIRTUAL_BIND(_debug_get_error); + GDVIRTUAL_BIND(_debug_get_stack_level_count); + + GDVIRTUAL_BIND(_debug_get_stack_level_line, "level"); + GDVIRTUAL_BIND(_debug_get_stack_level_function, "level"); + GDVIRTUAL_BIND(_debug_get_stack_level_locals, "level", "max_subitems", "max_depth"); + GDVIRTUAL_BIND(_debug_get_stack_level_members, "level", "max_subitems", "max_depth"); + GDVIRTUAL_BIND(_debug_get_stack_level_instance, "level"); + GDVIRTUAL_BIND(_debug_get_globals, "max_subitems", "max_depth"); + GDVIRTUAL_BIND(_debug_parse_stack_level_expression, "level", "expression", "max_subitems", "max_depth"); + + GDVIRTUAL_BIND(_debug_get_current_stack_info); + + GDVIRTUAL_BIND(_reload_all_scripts); + GDVIRTUAL_BIND(_reload_tool_script, "script", "soft_reload"); + + GDVIRTUAL_BIND(_get_recognized_extensions); + GDVIRTUAL_BIND(_get_public_functions); + GDVIRTUAL_BIND(_get_public_constants); + + GDVIRTUAL_BIND(_profiling_start); + GDVIRTUAL_BIND(_profiling_stop); + + GDVIRTUAL_BIND(_profiling_get_accumulated_data, "info_array", "info_max"); + GDVIRTUAL_BIND(_profiling_get_frame_data, "info_array", "info_max"); + + GDVIRTUAL_BIND(_alloc_instance_binding_data, "object"); + GDVIRTUAL_BIND(_free_instance_binding_data, "data"); + + GDVIRTUAL_BIND(_refcount_incremented_instance_binding, "object"); + GDVIRTUAL_BIND(_refcount_decremented_instance_binding, "object"); + + GDVIRTUAL_BIND(_frame); + + GDVIRTUAL_BIND(_handles_global_class_type, "type"); + GDVIRTUAL_BIND(_get_global_class_name, "path"); + + BIND_ENUM_CONSTANT(LOOKUP_RESULT_SCRIPT_LOCATION); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_CONSTANT); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_PROPERTY); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_METHOD); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_ENUM); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE); + BIND_ENUM_CONSTANT(LOOKUP_RESULT_MAX); + + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_CLASS); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_FUNCTION); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_SIGNAL); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_VARIABLE); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MEMBER); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_ENUM); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_CONSTANT); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_NODE_PATH); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_FILE_PATH); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_PLAIN_TEXT); + BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MAX); +} diff --git a/core/object/script_language_extension.h b/core/object/script_language_extension.h new file mode 100644 index 0000000000..b9ec79da26 --- /dev/null +++ b/core/object/script_language_extension.h @@ -0,0 +1,832 @@ +/*************************************************************************/ +/* script_language_extension.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef SCRIPT_LANGUAGE_EXTENSION_H +#define SCRIPT_LANGUAGE_EXTENSION_H + +#include "core/extension/ext_wrappers.gen.inc" +#include "core/object/gdvirtual.gen.inc" +#include "core/object/script_language.h" +#include "core/variant/native_ptr.h" +#include "core/variant/typed_array.h" + +class ScriptExtension : public Script { + GDCLASS(ScriptExtension, Script) + +protected: + EXBIND0R(bool, editor_can_reload_from_file) + + GDVIRTUAL1(_placeholder_erased, GDNativePtr<void>) + virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override { + GDVIRTUAL_CALL(_placeholder_erased, p_placeholder); + } + + static void _bind_methods(); + +public: + EXBIND0RC(bool, can_instantiate) + EXBIND0RC(Ref<Script>, get_base_script) + EXBIND1RC(bool, inherits_script, const Ref<Script> &) + EXBIND0RC(StringName, get_instance_base_type) + + GDVIRTUAL1RC(GDNativePtr<void>, _instance_create, Object *) + virtual ScriptInstance *instance_create(Object *p_this) override { + GDNativePtr<void> ret = nullptr; + GDVIRTUAL_REQUIRED_CALL(_instance_create, p_this, ret); + return reinterpret_cast<ScriptInstance *>(ret.operator void *()); + } + GDVIRTUAL1RC(GDNativePtr<void>, _placeholder_instance_create, Object *) + PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this) override { + GDNativePtr<void> ret = nullptr; + GDVIRTUAL_REQUIRED_CALL(_placeholder_instance_create, p_this, ret); + return reinterpret_cast<PlaceHolderScriptInstance *>(ret.operator void *()); + } + + EXBIND1RC(bool, instance_has, const Object *) + EXBIND0RC(bool, has_source_code) + EXBIND0RC(String, get_source_code) + EXBIND1(set_source_code, const String &) + EXBIND1R(Error, reload, bool) + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_documentation) +#ifdef TOOLS_ENABLED + virtual Vector<DocData::ClassDoc> get_documentation() const override { + TypedArray<Dictionary> doc; + GDVIRTUAL_REQUIRED_CALL(_get_documentation, doc); + + Vector<DocData::ClassDoc> class_doc; +#ifndef _MSC_VER +#warning missing conversion from documentation to ClassDoc +#endif + return class_doc; + } +#endif // TOOLS_ENABLED + + EXBIND1RC(bool, has_method, const StringName &) + + GDVIRTUAL1RC(Dictionary, _get_method_info, const StringName &) + virtual MethodInfo get_method_info(const StringName &p_method) const override { + Dictionary mi; + GDVIRTUAL_REQUIRED_CALL(_get_method_info, p_method, mi); + return MethodInfo::from_dict(mi); + } + + EXBIND0RC(bool, is_tool) + EXBIND0RC(bool, is_valid) + + EXBIND0RC(ScriptLanguage *, get_language) + EXBIND1RC(bool, has_script_signal, const StringName &) + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_signal_list) + + virtual void get_script_signal_list(List<MethodInfo> *r_signals) const override { + TypedArray<Dictionary> sl; + GDVIRTUAL_REQUIRED_CALL(_get_script_signal_list, sl); + for (int i = 0; i < sl.size(); i++) { + r_signals->push_back(MethodInfo::from_dict(sl[i])); + } + } + + GDVIRTUAL1RC(bool, _has_property_default_value, const StringName &) + GDVIRTUAL1RC(Variant, _get_property_default_value, const StringName &) + + virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const override { + bool has_dv = false; + if (!GDVIRTUAL_REQUIRED_CALL(_has_property_default_value, p_property, has_dv) || !has_dv) { + return false; + } + Variant ret; + GDVIRTUAL_REQUIRED_CALL(_get_property_default_value, p_property, ret); + return ret; + } + + EXBIND0(update_exports) + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_method_list) + + virtual void get_script_method_list(List<MethodInfo> *r_methods) const override { + TypedArray<Dictionary> sl; + GDVIRTUAL_REQUIRED_CALL(_get_script_method_list, sl); + for (int i = 0; i < sl.size(); i++) { + r_methods->push_back(MethodInfo::from_dict(sl[i])); + } + } + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_property_list) + + virtual void get_script_property_list(List<PropertyInfo> *r_propertys) const override { + TypedArray<Dictionary> sl; + GDVIRTUAL_REQUIRED_CALL(_get_script_property_list, sl); + for (int i = 0; i < sl.size(); i++) { + r_propertys->push_back(PropertyInfo::from_dict(sl[i])); + } + } + + EXBIND1RC(int, get_member_line, const StringName &) + + GDVIRTUAL0RC(Dictionary, _get_constants) + + virtual void get_constants(Map<StringName, Variant> *p_constants) override { + Dictionary constants; + GDVIRTUAL_REQUIRED_CALL(_get_constants, constants); + List<Variant> keys; + constants.get_key_list(&keys); + for (const Variant &K : keys) { + p_constants->insert(K, constants[K]); + } + } + GDVIRTUAL0RC(TypedArray<StringName>, _get_members) + virtual void get_members(Set<StringName> *p_members) override { + TypedArray<StringName> members; + GDVIRTUAL_REQUIRED_CALL(_get_members, members); + for (int i = 0; i < members.size(); i++) { + p_members->insert(members[i]); + } + } + + EXBIND0RC(bool, is_placeholder_fallback_enabled) + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_rpc_methods) + + virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const override { + TypedArray<Dictionary> ret; + GDVIRTUAL_REQUIRED_CALL(_get_rpc_methods, ret); + Vector<Multiplayer::RPCConfig> rpcret; + for (int i = 0; i < ret.size(); i++) { + Dictionary d = ret[i]; + Multiplayer::RPCConfig rpc; + ERR_CONTINUE(!d.has("name")); + rpc.name = d["name"]; + ERR_CONTINUE(!d.has("rpc_mode")); + rpc.rpc_mode = Multiplayer::RPCMode(int(d["rpc_mode"])); + ERR_CONTINUE(!d.has("call_local")); + rpc.call_local = d["call_local"]; + ERR_CONTINUE(!d.has("transfer_mode")); + rpc.transfer_mode = Multiplayer::TransferMode(int(d["transfer_mode"])); + ERR_CONTINUE(!d.has("channel")); + rpc.channel = d["channel"]; + rpcret.push_back(rpc); + } + return rpcret; + } + + ScriptExtension() {} +}; + +typedef ScriptLanguage::ProfilingInfo ScriptLanguageExtensionProfilingInfo; + +GDVIRTUAL_NATIVE_PTR(ScriptLanguageExtensionProfilingInfo) + +class ScriptLanguageExtension : public ScriptLanguage { + GDCLASS(ScriptLanguageExtension, ScriptLanguage) +protected: + static void _bind_methods(); + +public: + EXBIND0RC(String, get_name) + + EXBIND0(init) + EXBIND0RC(String, get_type) + EXBIND0RC(String, get_extension) + EXBIND1R(Error, execute_file, const String &) + EXBIND0(finish) + + /* EDITOR FUNCTIONS */ + + GDVIRTUAL0RC(Vector<String>, _get_reserved_words) + + virtual void get_reserved_words(List<String> *p_words) const override { + Vector<String> ret; + GDVIRTUAL_REQUIRED_CALL(_get_reserved_words, ret); + for (int i = 0; i < ret.size(); i++) { + p_words->push_back(ret[i]); + } + } + EXBIND1RC(bool, is_control_flow_keyword, String) + + GDVIRTUAL0RC(Vector<String>, _get_comment_delimiters) + + virtual void get_comment_delimiters(List<String> *p_words) const override { + Vector<String> ret; + GDVIRTUAL_REQUIRED_CALL(_get_comment_delimiters, ret); + for (int i = 0; i < ret.size(); i++) { + p_words->push_back(ret[i]); + } + } + + GDVIRTUAL0RC(Vector<String>, _get_string_delimiters) + + virtual void get_string_delimiters(List<String> *p_words) const override { + Vector<String> ret; + GDVIRTUAL_REQUIRED_CALL(_get_string_delimiters, ret); + for (int i = 0; i < ret.size(); i++) { + p_words->push_back(ret[i]); + } + } + + EXBIND3RC(Ref<Script>, make_template, const String &, const String &, const String &) + + GDVIRTUAL1RC(TypedArray<Dictionary>, _get_built_in_templates, StringName) + + virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override { + TypedArray<Dictionary> ret; + GDVIRTUAL_REQUIRED_CALL(_get_built_in_templates, p_object, ret); + Vector<ScriptTemplate> stret; + for (int i = 0; i < ret.size(); i++) { + Dictionary d = ret[i]; + ScriptTemplate st; + ERR_CONTINUE(!d.has("inherit")); + st.inherit = d["inherit"]; + ERR_CONTINUE(!d.has("name")); + st.name = d["name"]; + ERR_CONTINUE(!d.has("description")); + st.description = d["description"]; + ERR_CONTINUE(!d.has("content")); + st.content = d["content"]; + ERR_CONTINUE(!d.has("id")); + st.id = d["id"]; + ERR_CONTINUE(!d.has("origin")); + st.origin = TemplateLocation(int(d["origin"])); + stret.push_back(st); + } + return stret; + } + + EXBIND0R(bool, is_using_templates) + + GDVIRTUAL6RC(Dictionary, _validate, const String &, const String &, bool, bool, bool, bool) + virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, Set<int> *r_safe_lines = nullptr) const override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_validate, p_script, p_path, r_functions != nullptr, r_errors != nullptr, r_warnings != nullptr, r_safe_lines != nullptr, ret); + if (!ret.has("valid")) { + return false; + } + if (r_functions != nullptr && ret.has("functions")) { + Vector<String> functions = ret["functions"]; + for (int i = 0; i < functions.size(); i++) { + r_functions->push_back(functions[i]); + } + } + if (r_errors != nullptr && ret.has("errors")) { + Array errors = ret["errors"]; + for (int i = 0; i < errors.size(); i++) { + Dictionary err = errors[i]; + ERR_CONTINUE(!err.has("line")); + ERR_CONTINUE(!err.has("column")); + ERR_CONTINUE(!err.has("message")); + + ScriptError serr; + serr.line = err["line"]; + serr.column = err["column"]; + serr.message = err["message"]; + + r_errors->push_back(serr); + } + } + if (r_warnings != nullptr && ret.has("warnings")) { + ERR_FAIL_COND_V(!ret.has("warnings"), false); + Array warnings = ret["warnings"]; + for (int i = 0; i < warnings.size(); i++) { + Dictionary warn = warnings[i]; + ERR_CONTINUE(!warn.has("start_line")); + ERR_CONTINUE(!warn.has("end_line")); + ERR_CONTINUE(!warn.has("leftmost_column")); + ERR_CONTINUE(!warn.has("rightmost_column")); + ERR_CONTINUE(!warn.has("code")); + ERR_CONTINUE(!warn.has("string_code")); + ERR_CONTINUE(!warn.has("message")); + + Warning swarn; + swarn.start_line = warn["start_line"]; + swarn.end_line = warn["end_line"]; + swarn.leftmost_column = warn["leftmost_column"]; + swarn.rightmost_column = warn["rightmost_column"]; + swarn.code = warn["code"]; + swarn.string_code = warn["string_code"]; + swarn.message = warn["message"]; + + r_warnings->push_back(swarn); + } + } + if (r_safe_lines != nullptr && ret.has("safe_lines")) { + PackedInt32Array safe_lines = ret["safe_lines"]; + for (int i = 0; i < safe_lines.size(); i++) { + r_safe_lines->insert(safe_lines[i]); + } + } + return ret["valid"]; + } + + EXBIND1RC(String, validate_path, const String &) + GDVIRTUAL0RC(Object *, _create_script) + Script *create_script() const override { + Object *ret = nullptr; + GDVIRTUAL_REQUIRED_CALL(_create_script, ret); + return Object::cast_to<Script>(ret); + } + EXBIND0RC(bool, has_named_classes) + EXBIND0RC(bool, supports_builtin_mode) + EXBIND0RC(bool, supports_documentation) + EXBIND0RC(bool, can_inherit_from_file) + + EXBIND2RC(int, find_function, const String &, const String &) + EXBIND3RC(String, make_function, const String &, const String &, const PackedStringArray &) + EXBIND3R(Error, open_in_external_editor, const Ref<Script> &, int, int) + EXBIND0R(bool, overrides_external_editor) + + GDVIRTUAL3RC(Dictionary, _complete_code, const String &, const String &, Object *) + + virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_complete_code, p_code, p_path, p_owner, ret); + if (!ret.has("result")) { + return ERR_UNAVAILABLE; + } + + if (r_options != nullptr && ret.has("options")) { + Array options = ret["options"]; + for (int i = 0; i < options.size(); i++) { + Dictionary op = options[i]; + CodeCompletionOption option; + ERR_CONTINUE(!op.has("kind")); + option.kind = CodeCompletionKind(int(op["kind"])); + ERR_CONTINUE(!op.has("display")); + option.display = op["display"]; + ERR_CONTINUE(!op.has("insert_text")); + option.insert_text = op["insert_text"]; + ERR_CONTINUE(!op.has("font_color")); + option.font_color = op["font_color"]; + ERR_CONTINUE(!op.has("icon")); + option.icon = op["icon"]; + ERR_CONTINUE(!op.has("default_value")); + option.default_value = op["default_value"]; + if (op.has("matches")) { + PackedInt32Array matches = op["matches"]; + ERR_CONTINUE(matches.size() & 1); + for (int j = 0; j < matches.size(); j += 2) { + option.matches.push_back(Pair<int, int>(matches[j], matches[j + 1])); + } + } + r_options->push_back(option); + } + } + + ERR_FAIL_COND_V(!ret.has("force"), ERR_UNAVAILABLE); + r_force = ret["force"]; + ERR_FAIL_COND_V(!ret.has("call_hint"), ERR_UNAVAILABLE); + r_call_hint = ret["call_hint"]; + ERR_FAIL_COND_V(!ret.has("result"), ERR_UNAVAILABLE); + Error result = Error(int(ret["result"])); + + return result; + } + + GDVIRTUAL4RC(Dictionary, _lookup_code, const String &, const String &, const String &, Object *) + + virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_lookup_code, p_code, p_symbol, p_path, p_owner, ret); + if (!ret.has("result")) { + return ERR_UNAVAILABLE; + } + + ERR_FAIL_COND_V(!ret.has("type"), ERR_UNAVAILABLE); + r_result.type = LookupResultType(int(ret["type"])); + ERR_FAIL_COND_V(!ret.has("script"), ERR_UNAVAILABLE); + r_result.script = ret["script"]; + ERR_FAIL_COND_V(!ret.has("class_name"), ERR_UNAVAILABLE); + r_result.class_name = ret["class_name"]; + ERR_FAIL_COND_V(!ret.has("class_path"), ERR_UNAVAILABLE); + r_result.class_path = ret["class_path"]; + ERR_FAIL_COND_V(!ret.has("location"), ERR_UNAVAILABLE); + r_result.location = ret["location"]; + + Error result = Error(int(ret["result"])); + + return result; + } + + GDVIRTUAL3RC(String, _auto_indent_code, const String &, int, int) + virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override { + String ret; + GDVIRTUAL_REQUIRED_CALL(_auto_indent_code, p_code, p_from_line, p_to_line, ret); + p_code = ret; + } + EXBIND2(add_global_constant, const StringName &, const Variant &) + EXBIND2(add_named_global_constant, const StringName &, const Variant &) + EXBIND1(remove_named_global_constant, const StringName &) + + /* MULTITHREAD FUNCTIONS */ + + //some VMs need to be notified of thread creation/exiting to allocate a stack + EXBIND0(thread_enter) + EXBIND0(thread_exit) + + EXBIND0RC(String, debug_get_error) + EXBIND0RC(int, debug_get_stack_level_count) + EXBIND1RC(int, debug_get_stack_level_line, int) + EXBIND1RC(String, debug_get_stack_level_function, int) + EXBIND1RC(String, debug_get_stack_level_source, int) + + GDVIRTUAL3R(Dictionary, _debug_get_stack_level_locals, int, int, int) + virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_locals, p_level, p_max_subitems, p_max_depth, ret); + if (ret.size() == 0) { + return; + } + if (p_locals != nullptr && ret.has("locals")) { + PackedStringArray strings = ret["locals"]; + for (int i = 0; i < strings.size(); i++) { + p_locals->push_back(strings[i]); + } + } + if (p_values != nullptr && ret.has("values")) { + Array values = ret["values"]; + for (int i = 0; i < values.size(); i++) { + p_values->push_back(values[i]); + } + } + } + GDVIRTUAL3R(Dictionary, _debug_get_stack_level_members, int, int, int) + virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_members, p_level, p_max_subitems, p_max_depth, ret); + if (ret.size() == 0) { + return; + } + if (p_members != nullptr && ret.has("members")) { + PackedStringArray strings = ret["members"]; + for (int i = 0; i < strings.size(); i++) { + p_members->push_back(strings[i]); + } + } + if (p_values != nullptr && ret.has("values")) { + Array values = ret["values"]; + for (int i = 0; i < values.size(); i++) { + p_values->push_back(values[i]); + } + } + } + GDVIRTUAL1R(GDNativePtr<void>, _debug_get_stack_level_instance, int) + + virtual ScriptInstance *debug_get_stack_level_instance(int p_level) override { + GDNativePtr<void> ret = nullptr; + GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_instance, p_level, ret); + return reinterpret_cast<ScriptInstance *>(ret.operator void *()); + } + GDVIRTUAL2R(Dictionary, _debug_get_globals, int, int) + virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_debug_get_globals, p_max_subitems, p_max_depth, ret); + if (ret.size() == 0) { + return; + } + if (p_globals != nullptr && ret.has("globals")) { + PackedStringArray strings = ret["globals"]; + for (int i = 0; i < strings.size(); i++) { + p_globals->push_back(strings[i]); + } + } + if (p_values != nullptr && ret.has("values")) { + Array values = ret["values"]; + for (int i = 0; i < values.size(); i++) { + p_values->push_back(values[i]); + } + } + } + + EXBIND4R(String, debug_parse_stack_level_expression, int, const String &, int, int) + + GDVIRTUAL0R(TypedArray<Dictionary>, _debug_get_current_stack_info) + virtual Vector<StackInfo> debug_get_current_stack_info() override { + TypedArray<Dictionary> ret; + GDVIRTUAL_REQUIRED_CALL(_debug_get_current_stack_info, ret); + Vector<StackInfo> sret; + for (int i = 0; i < ret.size(); i++) { + StackInfo si; + Dictionary d = ret[i]; + ERR_CONTINUE(!d.has("file")); + ERR_CONTINUE(!d.has("func")); + ERR_CONTINUE(!d.has("line")); + si.file = d["file"]; + si.func = d["func"]; + si.line = d["line"]; + sret.push_back(si); + } + return sret; + } + + EXBIND0(reload_all_scripts) + EXBIND2(reload_tool_script, const Ref<Script> &, bool) + /* LOADER FUNCTIONS */ + + GDVIRTUAL0RC(PackedStringArray, _get_recognized_extensions) + + virtual void get_recognized_extensions(List<String> *p_extensions) const override { + PackedStringArray ret; + GDVIRTUAL_REQUIRED_CALL(_get_recognized_extensions, ret); + for (int i = 0; i < ret.size(); i++) { + p_extensions->push_back(ret[i]); + } + } + + GDVIRTUAL0RC(TypedArray<Dictionary>, _get_public_functions) + virtual void get_public_functions(List<MethodInfo> *p_functions) const override { + TypedArray<Dictionary> ret; + GDVIRTUAL_REQUIRED_CALL(_get_public_functions, ret); + for (int i = 0; i < ret.size(); i++) { + MethodInfo mi = MethodInfo::from_dict(ret[i]); + p_functions->push_back(mi); + } + } + GDVIRTUAL0RC(Dictionary, _get_public_constants) + virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_get_public_constants, ret); + for (int i = 0; i < ret.size(); i++) { + Dictionary d = ret[i]; + ERR_CONTINUE(!d.has("name")); + ERR_CONTINUE(!d.has("value")); + p_constants->push_back(Pair<String, Variant>(d["name"], d["value"])); + } + } + + EXBIND0(profiling_start) + EXBIND0(profiling_stop) + + GDVIRTUAL2R(int, _profiling_get_accumulated_data, GDNativePtr<ScriptLanguageExtensionProfilingInfo>, int) + + virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override { + int ret = 0; + GDVIRTUAL_REQUIRED_CALL(_profiling_get_accumulated_data, p_info_arr, p_info_max, ret); + return ret; + } + + GDVIRTUAL2R(int, _profiling_get_frame_data, GDNativePtr<ScriptLanguageExtensionProfilingInfo>, int) + + virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override { + int ret = 0; + GDVIRTUAL_REQUIRED_CALL(_profiling_get_accumulated_data, p_info_arr, p_info_max, ret); + return ret; + } + + GDVIRTUAL1R(GDNativePtr<void>, _alloc_instance_binding_data, Object *) + + virtual void *alloc_instance_binding_data(Object *p_object) override { + GDNativePtr<void> ret = nullptr; + GDVIRTUAL_REQUIRED_CALL(_alloc_instance_binding_data, p_object, ret); + return ret.operator void *(); + } + + GDVIRTUAL1(_free_instance_binding_data, GDNativePtr<void>) + + virtual void free_instance_binding_data(void *p_data) override { + GDVIRTUAL_REQUIRED_CALL(_free_instance_binding_data, p_data); + } + + EXBIND1(refcount_incremented_instance_binding, Object *) + EXBIND1R(bool, refcount_decremented_instance_binding, Object *) + + EXBIND0(frame) + + EXBIND1RC(bool, handles_global_class_type, const String &) + + GDVIRTUAL1RC(Dictionary, _get_global_class_name, const String &) + + virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const override { + Dictionary ret; + GDVIRTUAL_REQUIRED_CALL(_get_global_class_name, p_path, ret); + if (!ret.has("name")) { + return String(); + } + if (r_base_type != nullptr && ret.has("base_type")) { + *r_base_type = ret["base_type"]; + } + if (r_icon_path != nullptr && ret.has("icon_path")) { + *r_icon_path = ret["icon_path"]; + } + return ret["name"]; + } +}; + +VARIANT_ENUM_CAST(ScriptLanguageExtension::LookupResultType) +VARIANT_ENUM_CAST(ScriptLanguageExtension::CodeCompletionKind) + +class ScriptInstanceExtension : public ScriptInstance { +public: + const GDNativeExtensionScriptInstanceInfo *native_info; + GDNativeExtensionScriptInstanceDataPtr instance = nullptr; + +// There should not be warnings on explicit casts. +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wignored-qualifiers" +#endif + + virtual bool set(const StringName &p_name, const Variant &p_value) override { + if (native_info->set_func) { + return native_info->set_func(instance, (const GDNativeStringNamePtr)&p_name, (const GDNativeVariantPtr)&p_value); + } + return false; + } + virtual bool get(const StringName &p_name, Variant &r_ret) const override { + if (native_info->get_func) { + return native_info->get_func(instance, (const GDNativeStringNamePtr)&p_name, (GDNativeVariantPtr)&r_ret); + } + return false; + } + virtual void get_property_list(List<PropertyInfo> *p_list) const override { + if (native_info->get_property_list_func) { + uint32_t pcount; + const GDNativePropertyInfo *pinfo = native_info->get_property_list_func(instance, &pcount); + for (uint32_t i = 0; i < pcount; i++) { + p_list->push_back(PropertyInfo(Variant::Type(pinfo[i].type), pinfo[i].class_name, PropertyHint(pinfo[i].hint), pinfo[i].hint_string, pinfo[i].usage, pinfo[i].class_name)); + } + if (native_info->free_property_list_func) { + native_info->free_property_list_func(instance, pinfo); + } + } + } + virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const override { + if (native_info->get_property_type_func) { + GDNativeBool is_valid = 0; + GDNativeVariantType type = native_info->get_property_type_func(instance, (const GDNativeStringNamePtr)&p_name, &is_valid); + if (r_is_valid) { + *r_is_valid = is_valid != 0; + } + + return Variant::Type(type); + } + return Variant::NIL; + } + + virtual Object *get_owner() override { + if (native_info->get_owner_func) { + return (Object *)native_info->get_owner_func(instance); + } + return nullptr; + } + static void _add_property_with_state(const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value, void *p_userdata) { + List<Pair<StringName, Variant>> *state = (List<Pair<StringName, Variant>> *)p_userdata; + state->push_back(Pair<StringName, Variant>(*(const StringName *)p_name, *(const Variant *)p_value)); + } + virtual void get_property_state(List<Pair<StringName, Variant>> &state) override { + if (native_info->get_property_state_func) { + native_info->get_property_state_func(instance, _add_property_with_state, &state); + } + } + + virtual void get_method_list(List<MethodInfo> *p_list) const override { + if (native_info->get_method_list_func) { + uint32_t mcount; + const GDNativeMethodInfo *minfo = native_info->get_method_list_func(instance, &mcount); + for (uint32_t i = 0; i < mcount; i++) { + MethodInfo m; + m.name = minfo[i].name; + m.flags = minfo[i].flags; + m.id = minfo[i].id; + m.return_val = PropertyInfo(Variant::Type(minfo[i].return_value.type), minfo[i].return_value.class_name, PropertyHint(minfo[i].return_value.hint), minfo[i].return_value.hint_string, minfo[i].return_value.usage, minfo[i].return_value.class_name); + for (uint32_t j = 0; j < minfo[i].argument_count; j++) { + m.arguments.push_back(PropertyInfo(Variant::Type(minfo[i].arguments[j].type), minfo[i].arguments[j].class_name, PropertyHint(minfo[i].arguments[j].hint), minfo[i].arguments[j].hint_string, minfo[i].arguments[j].usage, minfo[i].arguments[j].class_name)); + } + const Variant *def_values = (const Variant *)minfo[i].default_arguments; + for (uint32_t j = 0; j < minfo[i].default_argument_count; j++) { + m.default_arguments.push_back(def_values[j]); + } + p_list->push_back(m); + } + if (native_info->free_method_list_func) { + native_info->free_method_list_func(instance, minfo); + } + } + } + virtual bool has_method(const StringName &p_method) const override { + if (native_info->has_method_func) { + return native_info->has_method_func(instance, (GDNativeStringNamePtr)&p_method); + } + return false; + } + + virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override { + Variant ret; + if (native_info->call_func) { + GDNativeCallError ce; + native_info->call_func(instance, (const GDNativeStringNamePtr)&p_method, (const GDNativeVariantPtr *)p_args, p_argcount, (GDNativeVariantPtr)&ret, &ce); + r_error.error = Callable::CallError::Error(ce.error); + r_error.argument = ce.argument; + r_error.expected = ce.expected; + } + return ret; + } + + virtual void notification(int p_notification) override { + if (native_info->notification_func) { + native_info->notification_func(instance, p_notification); + } + } + virtual String to_string(bool *r_valid) override { + if (native_info->to_string_func) { + GDNativeBool valid; + String ret = native_info->to_string_func(instance, &valid); + if (r_valid) { + *r_valid = valid != 0; + } + return ret; + } + return String(); + } + + virtual void refcount_incremented() override { + if (native_info->refcount_incremented_func) { + native_info->refcount_incremented_func(instance); + } + } + virtual bool refcount_decremented() override { + if (native_info->refcount_decremented_func) { + return native_info->refcount_decremented_func(instance); + } + return false; + } + + virtual Ref<Script> get_script() const override { + if (native_info->get_script_func) { + GDNativeObjectPtr script = native_info->get_script_func(instance); + return Ref<Script>(reinterpret_cast<Script *>(script)); + } + return Ref<Script>(); + } + + virtual bool is_placeholder() const override { + if (native_info->is_placeholder_func) { + return native_info->is_placeholder_func(instance); + } + return false; + } + + virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) override { + if (native_info->set_fallback_func) { + bool ret = native_info->set_fallback_func(instance, (const GDNativeStringNamePtr)&p_name, (const GDNativeVariantPtr)&p_value); + if (r_valid) { + *r_valid = ret; + } + } + } + virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid) override { + Variant ret; + if (native_info->get_fallback_func) { + bool valid = native_info->get_fallback_func(instance, (const GDNativeStringNamePtr)&p_name, (GDNativeVariantPtr)&ret); + if (r_valid) { + *r_valid = valid; + } + } + return ret; + } + + virtual ScriptLanguage *get_language() override { + if (native_info->get_language_func) { + GDNativeExtensionScriptLanguagePtr lang = native_info->get_language_func(instance); + return reinterpret_cast<ScriptLanguage *>(lang); + } + return nullptr; + ; + } + virtual ~ScriptInstanceExtension() { + if (native_info->free_func) { + native_info->free_func(instance); + } + } + +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +}; + +#endif // SCRIPT_LANGUAGE_EXTENSION_H diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp index 1a306e88fc..415b56cd83 100644 --- a/core/register_core_types.cpp +++ b/core/register_core_types.cpp @@ -71,6 +71,7 @@ #include "core/multiplayer/multiplayer_api.h" #include "core/multiplayer/multiplayer_peer.h" #include "core/object/class_db.h" +#include "core/object/script_language_extension.h" #include "core/object/undo_redo.h" #include "core/os/main_loop.h" #include "core/os/time.h" @@ -142,6 +143,10 @@ void register_core_types() { GDREGISTER_CLASS(Object); GDREGISTER_ABSTRACT_CLASS(Script); + GDREGISTER_ABSTRACT_CLASS(ScriptLanguage); + + GDREGISTER_VIRTUAL_CLASS(ScriptExtension); + GDREGISTER_VIRTUAL_CLASS(ScriptLanguageExtension); GDREGISTER_CLASS(RefCounted); GDREGISTER_CLASS(WeakRef); @@ -263,6 +268,7 @@ void register_core_types() { _engine_debugger = memnew(core_bind::EngineDebugger); GDREGISTER_NATIVE_STRUCT(AudioFrame, "float left;float right"); + GDREGISTER_NATIVE_STRUCT(ScriptLanguageExtensionProfilingInfo, "StringName signature;uint64_t call_count;uint64_t total_time;uint64_t self_time"); } void register_core_settings() { diff --git a/core/templates/vector.h b/core/templates/vector.h index 0877e04e01..d87e76139b 100644 --- a/core/templates/vector.h +++ b/core/templates/vector.h @@ -97,24 +97,29 @@ public: _FORCE_INLINE_ bool has(const T &p_val) const { return find(p_val) != -1; } - template <class C> - void sort_custom() { + void sort() { + sort_custom<_DefaultComparator<T>>(); + } + + template <class Comparator, bool Validate = SORT_ARRAY_VALIDATE_ENABLED, class... Args> + void sort_custom(Args &&...args) { int len = _cowdata.size(); if (len == 0) { return; } T *data = ptrw(); - SortArray<T, C> sorter; + SortArray<T, Comparator, Validate> sorter{ args... }; sorter.sort(data, len); } - void sort() { - sort_custom<_DefaultComparator<T>>(); + int bsearch(const T &p_value, bool p_before) { + return bsearch_custom<_DefaultComparator<T>>(p_value, p_before); } - int bsearch(const T &p_value, bool p_before) { - SearchArray<T> search; + template <class Comparator, class Value, class... Args> + int bsearch_custom(const Value &p_value, bool p_before, Args &&...args) { + SearchArray<T, Comparator> search{ args... }; return search.bisect(ptrw(), size(), p_value, p_before); } diff --git a/core/variant/array.cpp b/core/variant/array.cpp index 1b39558dff..afc4acadf9 100644 --- a/core/variant/array.cpp +++ b/core/variant/array.cpp @@ -484,24 +484,8 @@ void Array::sort() { _p->array.sort_custom<_ArrayVariantSort>(); } -struct _ArrayVariantSortCustom { - Callable func; - - _FORCE_INLINE_ bool operator()(const Variant &p_l, const Variant &p_r) const { - const Variant *args[2] = { &p_l, &p_r }; - Callable::CallError err; - Variant res; - func.call(args, 2, res, err); - ERR_FAIL_COND_V_MSG(err.error != Callable::CallError::CALL_OK, false, - "Error calling sorting method: " + Variant::get_callable_error_text(func, args, 1, err)); - return res; - } -}; - -void Array::sort_custom(Callable p_callable) { - SortArray<Variant, _ArrayVariantSortCustom, true> avs; - avs.compare.func = p_callable; - avs.sort(_p->array.ptrw(), _p->array.size()); +void Array::sort_custom(const Callable &p_callable) { + _p->array.sort_custom<CallableComparator, true>(p_callable); } void Array::shuffle() { @@ -524,13 +508,10 @@ int Array::bsearch(const Variant &p_value, bool p_before) { return avs.bisect(_p->array.ptrw(), _p->array.size(), p_value, p_before); } -int Array::bsearch_custom(const Variant &p_value, Callable p_callable, bool p_before) { +int Array::bsearch_custom(const Variant &p_value, const Callable &p_callable, bool p_before) { ERR_FAIL_COND_V(!_p->typed.validate(p_value, "custom binary search"), -1); - SearchArray<Variant, _ArrayVariantSortCustom> avs; - avs.compare.func = p_callable; - - return avs.bisect(_p->array.ptrw(), _p->array.size(), p_value, p_before); + return _p->array.bsearch_custom<CallableComparator>(p_value, p_before, p_callable); } void Array::reverse() { diff --git a/core/variant/array.h b/core/variant/array.h index 72bed5932c..ab5f7cd50f 100644 --- a/core/variant/array.h +++ b/core/variant/array.h @@ -82,10 +82,10 @@ public: Variant back() const; void sort(); - void sort_custom(Callable p_callable); + void sort_custom(const Callable &p_callable); void shuffle(); int bsearch(const Variant &p_value, bool p_before = true); - int bsearch_custom(const Variant &p_value, Callable p_callable, bool p_before = true); + int bsearch_custom(const Variant &p_value, const Callable &p_callable, bool p_before = true); void reverse(); int find(const Variant &p_value, int p_from = 0) const; diff --git a/core/variant/callable.cpp b/core/variant/callable.cpp index 48ed48d120..516b8f2d51 100644 --- a/core/variant/callable.cpp +++ b/core/variant/callable.cpp @@ -429,3 +429,13 @@ Signal::Signal(ObjectID p_object, const StringName &p_name) { object = p_object; name = p_name; } + +bool CallableComparator::operator()(const Variant &p_l, const Variant &p_r) const { + const Variant *args[2] = { &p_l, &p_r }; + Callable::CallError err; + Variant res; + func.call(args, 2, res, err); + ERR_FAIL_COND_V_MSG(err.error != Callable::CallError::CALL_OK, false, + "Error calling compare method: " + Variant::get_callable_error_text(func, args, 1, err)); + return res; +} diff --git a/core/variant/callable.h b/core/variant/callable.h index c61870f194..6a760958d6 100644 --- a/core/variant/callable.h +++ b/core/variant/callable.h @@ -170,4 +170,10 @@ public: Signal() {} }; +struct CallableComparator { + const Callable &func; + + bool operator()(const Variant &p_l, const Variant &p_r) const; +}; + #endif // CALLABLE_H diff --git a/core/variant/variant_call.cpp b/core/variant/variant_call.cpp index a02f9c5823..c11925fa8c 100644 --- a/core/variant/variant_call.cpp +++ b/core/variant/variant_call.cpp @@ -1656,6 +1656,8 @@ static void _register_variant_builtin_methods() { bind_method(Color, darkened, sarray("amount"), varray()); bind_method(Color, blend, sarray("over"), varray()); bind_method(Color, get_luminance, sarray(), varray()); + bind_method(Color, to_linear, sarray(), varray()); + bind_method(Color, to_srgb, sarray(), varray()); bind_method(Color, is_equal_approx, sarray("to"), varray()); diff --git a/doc/classes/Color.xml b/doc/classes/Color.xml index e30d448a27..5b48804d9d 100644 --- a/doc/classes/Color.xml +++ b/doc/classes/Color.xml @@ -183,6 +183,7 @@ <description> Returns the luminance of the color in the [code][0.0, 1.0][/code] range. This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark. + [b]Note:[/b] [method get_luminance] relies on the colour being in the linear color space to return an accurate relative luminance value. If the color is in the sRGB color space, use [method to_linear] to convert it to the linear color space first. </description> </method> <method name="get_named_color" qualifiers="static"> @@ -404,6 +405,12 @@ [/codeblocks] </description> </method> + <method name="to_linear" qualifiers="const"> + <return type="Color" /> + <description> + Returns the color converted to the linear color space. This assumes the original color is in the sRGB color space. See also [method to_srgb] which performs the opposite operation. + </description> + </method> <method name="to_rgba32" qualifiers="const"> <return type="int" /> <description> @@ -436,6 +443,12 @@ [/codeblocks] </description> </method> + <method name="to_srgb" qualifiers="const"> + <return type="Color" /> + <description> + Returns the color converted to the [url=https://en.wikipedia.org/wiki/SRGB]sRGB[/url] color space. This assumes the original color is in the linear color space. See also [method to_linear] which performs the opposite operation. + </description> + </method> </methods> <members> <member name="a" type="float" setter="" getter="" default="1.0"> diff --git a/doc/classes/Control.xml b/doc/classes/Control.xml index 3163ac5610..78150af9dd 100644 --- a/doc/classes/Control.xml +++ b/doc/classes/Control.xml @@ -943,9 +943,9 @@ </method> <method name="warp_mouse"> <return type="void" /> - <argument index="0" name="to_position" type="Vector2" /> + <argument index="0" name="position" type="Vector2" /> <description> - Moves the mouse cursor to [code]to_position[/code], relative to [member position] of this [Control]. + Moves the mouse cursor to [code]position[/code], relative to [member position] of this [Control]. </description> </method> </methods> diff --git a/doc/classes/DisplayServer.xml b/doc/classes/DisplayServer.xml index 47bc496100..16a2019149 100644 --- a/doc/classes/DisplayServer.xml +++ b/doc/classes/DisplayServer.xml @@ -670,13 +670,6 @@ <description> </description> </method> - <method name="mouse_warp_to_position"> - <return type="void" /> - <argument index="0" name="position" type="Vector2i" /> - <description> - Sets the mouse cursor position to the given [code]position[/code]. - </description> - </method> <method name="process_events"> <return type="void" /> <description> @@ -852,6 +845,13 @@ [b]Note:[/b] This method is implemented on Android, iOS and UWP. </description> </method> + <method name="warp_mouse"> + <return type="void" /> + <argument index="0" name="position" type="Vector2i" /> + <description> + Sets the mouse cursor position to the given [code]position[/code] relative to an origin at the upper left corner of the currently focused game Window Manager window. + </description> + </method> <method name="window_attach_instance_id"> <return type="void" /> <argument index="0" name="instance_id" type="int" /> diff --git a/doc/classes/Engine.xml b/doc/classes/Engine.xml index af4df321c1..506992e3af 100644 --- a/doc/classes/Engine.xml +++ b/doc/classes/Engine.xml @@ -94,6 +94,17 @@ [/codeblock] </description> </method> + <method name="get_script_language" qualifiers="const"> + <return type="ScriptLanguage" /> + <argument index="0" name="index" type="int" /> + <description> + </description> + </method> + <method name="get_script_language_count"> + <return type="int" /> + <description> + </description> + </method> <method name="get_singleton" qualifiers="const"> <return type="Object" /> <argument index="0" name="name" type="StringName" /> @@ -167,6 +178,12 @@ Returns [code]true[/code] if the game is inside the fixed process and physics phase of the game loop. </description> </method> + <method name="register_script_language"> + <return type="void" /> + <argument index="0" name="language" type="ScriptLanguage" /> + <description> + </description> + </method> <method name="register_singleton"> <return type="void" /> <argument index="0" name="name" type="StringName" /> diff --git a/doc/classes/HTTPRequest.xml b/doc/classes/HTTPRequest.xml index 42047a68c8..641d73e333 100644 --- a/doc/classes/HTTPRequest.xml +++ b/doc/classes/HTTPRequest.xml @@ -247,7 +247,7 @@ <member name="max_redirects" type="int" setter="set_max_redirects" getter="get_max_redirects" default="8"> Maximum number of allowed redirects. </member> - <member name="timeout" type="int" setter="set_timeout" getter="get_timeout" default="0"> + <member name="timeout" type="float" setter="set_timeout" getter="get_timeout" default="0.0"> </member> <member name="use_threads" type="bool" setter="set_use_threads" getter="is_using_threads" default="false"> If [code]true[/code], multithreading is used to improve performance. diff --git a/doc/classes/Input.xml b/doc/classes/Input.xml index 64a914bb31..c3552c9f62 100644 --- a/doc/classes/Input.xml +++ b/doc/classes/Input.xml @@ -379,11 +379,11 @@ [b]Note:[/b] It needs [code]VIBRATE[/code] permission for Android at export settings. iOS does not support duration. </description> </method> - <method name="warp_mouse_position"> + <method name="warp_mouse"> <return type="void" /> - <argument index="0" name="to" type="Vector2" /> + <argument index="0" name="position" type="Vector2" /> <description> - Sets the mouse position to the specified vector, provided in pixels and relative to an origin at the upper left corner of the game window. + Sets the mouse position to the specified vector, provided in pixels and relative to an origin at the upper left corner of the currently focused Window Manager game window. Mouse position is clipped to the limits of the screen resolution, or to the limits of the game window if [enum MouseMode] is set to [code]MOUSE_MODE_CONFINED[/code] or [code]MOUSE_MODE_CONFINED_HIDDEN[/code]. </description> </method> diff --git a/doc/classes/Range.xml b/doc/classes/Range.xml index 9743d969ca..df6efd155a 100644 --- a/doc/classes/Range.xml +++ b/doc/classes/Range.xml @@ -11,7 +11,7 @@ <methods> <method name="_value_changed" qualifiers="virtual"> <return type="void" /> - <argument index="0" name="" type="float" /> + <argument index="0" name="new_value" type="float" /> <description> Called when the [Range]'s value is changed (following the same conditions as [signal value_changed]). </description> diff --git a/doc/classes/ScriptExtension.xml b/doc/classes/ScriptExtension.xml new file mode 100644 index 0000000000..91fa6206d7 --- /dev/null +++ b/doc/classes/ScriptExtension.xml @@ -0,0 +1,173 @@ +<?xml version="1.0" encoding="UTF-8" ?> +<class name="ScriptExtension" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd"> + <brief_description> + </brief_description> + <description> + </description> + <tutorials> + </tutorials> + <methods> + <method name="_can_instantiate" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_editor_can_reload_from_file" qualifiers="virtual"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_get_base_script" qualifiers="virtual const"> + <return type="Script" /> + <description> + </description> + </method> + <method name="_get_constants" qualifiers="virtual const"> + <return type="Dictionary" /> + <description> + </description> + </method> + <method name="_get_documentation" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_instance_base_type" qualifiers="virtual const"> + <return type="StringName" /> + <description> + </description> + </method> + <method name="_get_language" qualifiers="virtual const"> + <return type="ScriptLanguage" /> + <description> + </description> + </method> + <method name="_get_member_line" qualifiers="virtual const"> + <return type="int" /> + <argument index="0" name="member" type="StringName" /> + <description> + </description> + </method> + <method name="_get_members" qualifiers="virtual const"> + <return type="StringName[]" /> + <description> + </description> + </method> + <method name="_get_method_info" qualifiers="virtual const"> + <return type="Dictionary" /> + <argument index="0" name="method" type="StringName" /> + <description> + </description> + </method> + <method name="_get_property_default_value" qualifiers="virtual const"> + <return type="Variant" /> + <argument index="0" name="property" type="StringName" /> + <description> + </description> + </method> + <method name="_get_rpc_methods" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_script_method_list" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_script_property_list" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_script_signal_list" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_source_code" qualifiers="virtual const"> + <return type="String" /> + <description> + </description> + </method> + <method name="_has_method" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="method" type="StringName" /> + <description> + </description> + </method> + <method name="_has_script_signal" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="signal" type="StringName" /> + <description> + </description> + </method> + <method name="_has_source_code" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_inherits_script" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="script" type="Script" /> + <description> + </description> + </method> + <method name="_instance_create" qualifiers="virtual const"> + <return type="void*" /> + <argument index="0" name="for_object" type="Object" /> + <description> + </description> + </method> + <method name="_instance_has" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="object" type="Object" /> + <description> + </description> + </method> + <method name="_is_placeholder_fallback_enabled" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_is_tool" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_is_valid" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_placeholder_erased" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="placeholder" type="void*" /> + <description> + </description> + </method> + <method name="_placeholder_instance_create" qualifiers="virtual const"> + <return type="void*" /> + <argument index="0" name="for_object" type="Object" /> + <description> + </description> + </method> + <method name="_reload" qualifiers="virtual"> + <return type="int" enum="Error" /> + <argument index="0" name="keep_state" type="bool" /> + <description> + </description> + </method> + <method name="_set_source_code" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="code" type="String" /> + <description> + </description> + </method> + <method name="_update_exports" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + </methods> +</class> diff --git a/doc/classes/ScriptLanguage.xml b/doc/classes/ScriptLanguage.xml new file mode 100644 index 0000000000..b229e461f5 --- /dev/null +++ b/doc/classes/ScriptLanguage.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8" ?> +<class name="ScriptLanguage" inherits="Object" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd"> + <brief_description> + </brief_description> + <description> + </description> + <tutorials> + </tutorials> +</class> diff --git a/doc/classes/ScriptLanguageExtension.xml b/doc/classes/ScriptLanguageExtension.xml new file mode 100644 index 0000000000..7225d93030 --- /dev/null +++ b/doc/classes/ScriptLanguageExtension.xml @@ -0,0 +1,404 @@ +<?xml version="1.0" encoding="UTF-8" ?> +<class name="ScriptLanguageExtension" inherits="ScriptLanguage" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd"> + <brief_description> + </brief_description> + <description> + </description> + <tutorials> + </tutorials> + <methods> + <method name="_add_global_constant" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="name" type="StringName" /> + <argument index="1" name="value" type="Variant" /> + <description> + </description> + </method> + <method name="_add_named_global_constant" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="name" type="StringName" /> + <argument index="1" name="value" type="Variant" /> + <description> + </description> + </method> + <method name="_alloc_instance_binding_data" qualifiers="virtual"> + <return type="void*" /> + <argument index="0" name="object" type="Object" /> + <description> + </description> + </method> + <method name="_auto_indent_code" qualifiers="virtual const"> + <return type="String" /> + <argument index="0" name="code" type="String" /> + <argument index="1" name="from_line" type="int" /> + <argument index="2" name="to_line" type="int" /> + <description> + </description> + </method> + <method name="_can_inherit_from_file" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_complete_code" qualifiers="virtual const"> + <return type="Dictionary" /> + <argument index="0" name="code" type="String" /> + <argument index="1" name="path" type="String" /> + <argument index="2" name="owner" type="Object" /> + <description> + </description> + </method> + <method name="_create_script" qualifiers="virtual const"> + <return type="Object" /> + <description> + </description> + </method> + <method name="_debug_get_current_stack_info" qualifiers="virtual"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_debug_get_error" qualifiers="virtual const"> + <return type="String" /> + <description> + </description> + </method> + <method name="_debug_get_globals" qualifiers="virtual"> + <return type="Dictionary" /> + <argument index="0" name="max_subitems" type="int" /> + <argument index="1" name="max_depth" type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_count" qualifiers="virtual const"> + <return type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_function" qualifiers="virtual const"> + <return type="String" /> + <argument index="0" name="level" type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_instance" qualifiers="virtual"> + <return type="void*" /> + <argument index="0" name="level" type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_line" qualifiers="virtual const"> + <return type="int" /> + <argument index="0" name="level" type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_locals" qualifiers="virtual"> + <return type="Dictionary" /> + <argument index="0" name="level" type="int" /> + <argument index="1" name="max_subitems" type="int" /> + <argument index="2" name="max_depth" type="int" /> + <description> + </description> + </method> + <method name="_debug_get_stack_level_members" qualifiers="virtual"> + <return type="Dictionary" /> + <argument index="0" name="level" type="int" /> + <argument index="1" name="max_subitems" type="int" /> + <argument index="2" name="max_depth" type="int" /> + <description> + </description> + </method> + <method name="_debug_parse_stack_level_expression" qualifiers="virtual"> + <return type="String" /> + <argument index="0" name="level" type="int" /> + <argument index="1" name="expression" type="String" /> + <argument index="2" name="max_subitems" type="int" /> + <argument index="3" name="max_depth" type="int" /> + <description> + </description> + </method> + <method name="_execute_file" qualifiers="virtual"> + <return type="int" enum="Error" /> + <argument index="0" name="path" type="String" /> + <description> + </description> + </method> + <method name="_find_function" qualifiers="virtual const"> + <return type="int" /> + <argument index="0" name="class_name" type="String" /> + <argument index="1" name="function_name" type="String" /> + <description> + </description> + </method> + <method name="_finish" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_frame" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_free_instance_binding_data" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="data" type="void*" /> + <description> + </description> + </method> + <method name="_get_built_in_templates" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <argument index="0" name="object" type="StringName" /> + <description> + </description> + </method> + <method name="_get_comment_delimiters" qualifiers="virtual const"> + <return type="PackedStringArray" /> + <description> + </description> + </method> + <method name="_get_extension" qualifiers="virtual const"> + <return type="String" /> + <description> + </description> + </method> + <method name="_get_global_class_name" qualifiers="virtual const"> + <return type="Dictionary" /> + <argument index="0" name="path" type="String" /> + <description> + </description> + </method> + <method name="_get_name" qualifiers="virtual const"> + <return type="String" /> + <description> + </description> + </method> + <method name="_get_public_constants" qualifiers="virtual const"> + <return type="Dictionary" /> + <description> + </description> + </method> + <method name="_get_public_functions" qualifiers="virtual const"> + <return type="Dictionary[]" /> + <description> + </description> + </method> + <method name="_get_recognized_extensions" qualifiers="virtual const"> + <return type="PackedStringArray" /> + <description> + </description> + </method> + <method name="_get_reserved_words" qualifiers="virtual const"> + <return type="PackedStringArray" /> + <description> + </description> + </method> + <method name="_get_string_delimiters" qualifiers="virtual const"> + <return type="PackedStringArray" /> + <description> + </description> + </method> + <method name="_get_type" qualifiers="virtual const"> + <return type="String" /> + <description> + </description> + </method> + <method name="_handles_global_class_type" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="type" type="String" /> + <description> + </description> + </method> + <method name="_has_named_classes" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_init" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_is_control_flow_keyword" qualifiers="virtual const"> + <return type="bool" /> + <argument index="0" name="keyword" type="String" /> + <description> + </description> + </method> + <method name="_is_using_templates" qualifiers="virtual"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_lookup_code" qualifiers="virtual const"> + <return type="Dictionary" /> + <argument index="0" name="code" type="String" /> + <argument index="1" name="symbol" type="String" /> + <argument index="2" name="path" type="String" /> + <argument index="3" name="owner" type="Object" /> + <description> + </description> + </method> + <method name="_make_function" qualifiers="virtual const"> + <return type="String" /> + <argument index="0" name="class_name" type="String" /> + <argument index="1" name="function_name" type="String" /> + <argument index="2" name="function_args" type="PackedStringArray" /> + <description> + </description> + </method> + <method name="_make_template" qualifiers="virtual const"> + <return type="Script" /> + <argument index="0" name="template" type="String" /> + <argument index="1" name="class_name" type="String" /> + <argument index="2" name="base_class_name" type="String" /> + <description> + </description> + </method> + <method name="_open_in_external_editor" qualifiers="virtual"> + <return type="int" enum="Error" /> + <argument index="0" name="script" type="Script" /> + <argument index="1" name="line" type="int" /> + <argument index="2" name="column" type="int" /> + <description> + </description> + </method> + <method name="_overrides_external_editor" qualifiers="virtual"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_profiling_get_accumulated_data" qualifiers="virtual"> + <return type="int" /> + <argument index="0" name="info_array" type="ScriptLanguageExtensionProfilingInfo*" /> + <argument index="1" name="info_max" type="int" /> + <description> + </description> + </method> + <method name="_profiling_get_frame_data" qualifiers="virtual"> + <return type="int" /> + <argument index="0" name="info_array" type="ScriptLanguageExtensionProfilingInfo*" /> + <argument index="1" name="info_max" type="int" /> + <description> + </description> + </method> + <method name="_profiling_start" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_profiling_stop" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_refcount_decremented_instance_binding" qualifiers="virtual"> + <return type="bool" /> + <argument index="0" name="object" type="Object" /> + <description> + </description> + </method> + <method name="_refcount_incremented_instance_binding" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="object" type="Object" /> + <description> + </description> + </method> + <method name="_reload_all_scripts" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_reload_tool_script" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="script" type="Script" /> + <argument index="1" name="soft_reload" type="bool" /> + <description> + </description> + </method> + <method name="_remove_named_global_constant" qualifiers="virtual"> + <return type="void" /> + <argument index="0" name="name" type="StringName" /> + <description> + </description> + </method> + <method name="_supports_builtin_mode" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_supports_documentation" qualifiers="virtual const"> + <return type="bool" /> + <description> + </description> + </method> + <method name="_thread_enter" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_thread_exit" qualifiers="virtual"> + <return type="void" /> + <description> + </description> + </method> + <method name="_validate" qualifiers="virtual const"> + <return type="Dictionary" /> + <argument index="0" name="script" type="String" /> + <argument index="1" name="path" type="String" /> + <argument index="2" name="validate_functions" type="bool" /> + <argument index="3" name="validate_errors" type="bool" /> + <argument index="4" name="validate_warnings" type="bool" /> + <argument index="5" name="validate_safe_lines" type="bool" /> + <description> + </description> + </method> + <method name="_validate_path" qualifiers="virtual const"> + <return type="String" /> + <argument index="0" name="path" type="String" /> + <description> + </description> + </method> + </methods> + <constants> + <constant name="LOOKUP_RESULT_SCRIPT_LOCATION" value="0" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS" value="1" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS_CONSTANT" value="2" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS_PROPERTY" value="3" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS_METHOD" value="4" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS_ENUM" value="5" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE" value="6" enum="LookupResultType"> + </constant> + <constant name="LOOKUP_RESULT_MAX" value="7" enum="LookupResultType"> + </constant> + <constant name="CODE_COMPLETION_KIND_CLASS" value="0" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_FUNCTION" value="1" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_SIGNAL" value="2" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_VARIABLE" value="3" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_MEMBER" value="4" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_ENUM" value="5" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_CONSTANT" value="6" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_NODE_PATH" value="7" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_FILE_PATH" value="8" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind"> + </constant> + <constant name="CODE_COMPLETION_KIND_MAX" value="10" enum="CodeCompletionKind"> + </constant> + </constants> +</class> diff --git a/doc/classes/String.xml b/doc/classes/String.xml index 9a6155c8a8..8108c5eb46 100644 --- a/doc/classes/String.xml +++ b/doc/classes/String.xml @@ -633,8 +633,8 @@ var some_string = "One,Two,Three,Four" var some_array = some_string.rsplit(",", true, 1) print(some_array.size()) # Prints 2 - print(some_array[0]) # Prints "Four" - print(some_array[1]) # Prints "Three,Two,One" + print(some_array[0]) # Prints "One,Two,Three" + print(some_array[1]) # Prints "Four" [/gdscript] [csharp] // There is no Rsplit. diff --git a/doc/classes/TabBar.xml b/doc/classes/TabBar.xml index 420ab2adeb..aca5e2d7f3 100644 --- a/doc/classes/TabBar.xml +++ b/doc/classes/TabBar.xml @@ -323,6 +323,9 @@ </constant> </constants> <theme_items> + <theme_item name="drop_mark_color" data_type="color" type="Color" default="Color(1, 1, 1, 1)"> + Modulation color for the [theme_item drop_mark] icon. + </theme_item> <theme_item name="font_disabled_color" data_type="color" type="Color" default="Color(0.875, 0.875, 0.875, 0.5)"> Font color of disabled tabs. </theme_item> @@ -356,6 +359,9 @@ <theme_item name="decrement_highlight" data_type="icon" type="Texture2D"> Icon for the left arrow button that appears when there are too many tabs to fit in the container width. Used when the button is being hovered with the cursor. </theme_item> + <theme_item name="drop_mark" data_type="icon" type="Texture2D"> + Icon shown to indicate where a dragged tab is gonna be dropped (see [member drag_to_rearrange_enabled]). + </theme_item> <theme_item name="increment" data_type="icon" type="Texture2D"> Icon for the right arrow button that appears when there are too many tabs to fit in the container width. When the button is disabled (i.e. the last tab is visible) it appears semi-transparent. </theme_item> diff --git a/doc/classes/TabContainer.xml b/doc/classes/TabContainer.xml index ec2be012e9..c506152546 100644 --- a/doc/classes/TabContainer.xml +++ b/doc/classes/TabContainer.xml @@ -172,6 +172,9 @@ </signal> </signals> <theme_items> + <theme_item name="drop_mark_color" data_type="color" type="Color" default="Color(1, 1, 1, 1)"> + Modulation color for the [theme_item drop_mark] icon. + </theme_item> <theme_item name="font_disabled_color" data_type="color" type="Color" default="Color(0.875, 0.875, 0.875, 0.5)"> Font color of disabled tabs. </theme_item> @@ -206,6 +209,9 @@ <theme_item name="decrement_highlight" data_type="icon" type="Texture2D"> Icon for the left arrow button that appears when there are too many tabs to fit in the container width. Used when the button is being hovered with the cursor. </theme_item> + <theme_item name="drop_mark" data_type="icon" type="Texture2D"> + Icon shown to indicate where a dragged tab is gonna be dropped (see [member drag_to_rearrange_enabled]). + </theme_item> <theme_item name="increment" data_type="icon" type="Texture2D"> Icon for the right arrow button that appears when there are too many tabs to fit in the container width. When the button is disabled (i.e. the last tab is visible) it appears semi-transparent. </theme_item> diff --git a/doc/classes/Viewport.xml b/doc/classes/Viewport.xml index a72e7f1eb0..b5916f8c17 100644 --- a/doc/classes/Viewport.xml +++ b/doc/classes/Viewport.xml @@ -172,7 +172,7 @@ </method> <method name="warp_mouse"> <return type="void" /> - <argument index="0" name="to_position" type="Vector2" /> + <argument index="0" name="position" type="Vector2" /> <description> Moves the mouse pointer to the specified position in this [Viewport] using the coordinate system of this [Viewport]. </description> diff --git a/editor/code_editor.cpp b/editor/code_editor.cpp index 2896fda2d2..b6da21bc79 100644 --- a/editor/code_editor.cpp +++ b/editor/code_editor.cpp @@ -854,7 +854,7 @@ void CodeTextEditor::_code_complete_timer_timeout() { } void CodeTextEditor::_complete_request() { - List<ScriptCodeCompletionOption> entries; + List<ScriptLanguage::CodeCompletionOption> entries; String ctext = text_editor->get_text_for_code_completion(); _code_complete_script(ctext, &entries); bool forced = false; @@ -865,7 +865,7 @@ void CodeTextEditor::_complete_request() { return; } - for (const ScriptCodeCompletionOption &e : entries) { + for (const ScriptLanguage::CodeCompletionOption &e : entries) { Color font_color = completion_font_color; if (e.insert_text.begins_with("\"") || e.insert_text.begins_with("\'")) { font_color = completion_string_color; @@ -877,41 +877,41 @@ void CodeTextEditor::_complete_request() { text_editor->update_code_completion_options(forced); } -Ref<Texture2D> CodeTextEditor::_get_completion_icon(const ScriptCodeCompletionOption &p_option) { +Ref<Texture2D> CodeTextEditor::_get_completion_icon(const ScriptLanguage::CodeCompletionOption &p_option) { Ref<Texture2D> tex; switch (p_option.kind) { - case ScriptCodeCompletionOption::KIND_CLASS: { + case ScriptLanguage::CODE_COMPLETION_KIND_CLASS: { if (has_theme_icon(p_option.display, SNAME("EditorIcons"))) { tex = get_theme_icon(p_option.display, SNAME("EditorIcons")); } else { tex = get_theme_icon(SNAME("Object"), SNAME("EditorIcons")); } } break; - case ScriptCodeCompletionOption::KIND_ENUM: + case ScriptLanguage::CODE_COMPLETION_KIND_ENUM: tex = get_theme_icon(SNAME("Enum"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_FILE_PATH: + case ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH: tex = get_theme_icon(SNAME("File"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_NODE_PATH: + case ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH: tex = get_theme_icon(SNAME("NodePath"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_VARIABLE: + case ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE: tex = get_theme_icon(SNAME("Variant"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_CONSTANT: + case ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT: tex = get_theme_icon(SNAME("MemberConstant"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_MEMBER: + case ScriptLanguage::CODE_COMPLETION_KIND_MEMBER: tex = get_theme_icon(SNAME("MemberProperty"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_SIGNAL: + case ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL: tex = get_theme_icon(SNAME("MemberSignal"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_FUNCTION: + case ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION: tex = get_theme_icon(SNAME("MemberMethod"), SNAME("EditorIcons")); break; - case ScriptCodeCompletionOption::KIND_PLAIN_TEXT: + case ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT: tex = get_theme_icon(SNAME("BoxMesh"), SNAME("EditorIcons")); break; default: diff --git a/editor/code_editor.h b/editor/code_editor.h index d7025e7fd9..bbc45d6ec0 100644 --- a/editor/code_editor.h +++ b/editor/code_editor.h @@ -134,7 +134,7 @@ public: FindReplaceBar(); }; -typedef void (*CodeTextEditorCodeCompleteFunc)(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_forced); +typedef void (*CodeTextEditorCodeCompleteFunc)(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced); class CodeTextEditor : public VBoxContainer { GDCLASS(CodeTextEditor, VBoxContainer); @@ -166,7 +166,7 @@ class CodeTextEditor : public VBoxContainer { void _update_text_editor_theme(); void _complete_request(); - Ref<Texture2D> _get_completion_icon(const ScriptCodeCompletionOption &p_option); + Ref<Texture2D> _get_completion_icon(const ScriptLanguage::CodeCompletionOption &p_option); void _font_resize_timeout(); bool _add_font_size(int p_delta); @@ -197,7 +197,7 @@ class CodeTextEditor : public VBoxContainer { protected: virtual void _load_theme_settings() {} virtual void _validate_script() {} - virtual void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) {} + virtual void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) {} void _text_changed_idle_timeout(); void _code_complete_timer_timeout(); diff --git a/editor/editor_file_dialog.cpp b/editor/editor_file_dialog.cpp index 0c2faacf02..ab403c4212 100644 --- a/editor/editor_file_dialog.cpp +++ b/editor/editor_file_dialog.cpp @@ -781,12 +781,19 @@ void EditorFileDialog::update_file_list() { continue; } - if (show_hidden_files || !dir_access->current_is_hidden()) { + if (show_hidden_files) { if (!dir_access->current_is_dir()) { files.push_back(item); } else { dirs.push_back(item); } + } else if (!dir_access->current_is_hidden()) { + String full_path = cdir == "res://" ? item : dir_access->get_current_dir() + "/" + item; + if (dir_access->current_is_dir() && !EditorFileSystem::_should_skip_directory(full_path)) { + dirs.push_back(item); + } else { + files.push_back(item); + } } item = dir_access->get_next(); } @@ -1301,6 +1308,18 @@ void EditorFileDialog::_update_favorites() { favorite->set_pressed(false); Vector<String> favorited = EditorSettings::get_singleton()->get_favorites(); + + bool fav_changed = false; + for (int i = favorited.size() - 1; i >= 0; i--) { + if (!dir_access->dir_exists(favorited[i])) { + favorited.remove_at(i); + fav_changed = true; + } + } + if (fav_changed) { + EditorSettings::get_singleton()->set_favorites(favorited); + } + for (int i = 0; i < favorited.size(); i++) { bool cres = favorited[i].begins_with("res://"); if (cres != res) { diff --git a/editor/editor_file_system.cpp b/editor/editor_file_system.cpp index 98ba3ae3d8..f3d9449c6c 100644 --- a/editor/editor_file_system.cpp +++ b/editor/editor_file_system.cpp @@ -888,7 +888,7 @@ void EditorFileSystem::_scan_new_dir(EditorFileSystemDirectory *p_dir, DirAccess if (script == nullptr) { continue; } - const Vector<DocData::ClassDoc> &docs = script->get_documentation(); + Vector<DocData::ClassDoc> docs = script->get_documentation(); for (int j = 0; j < docs.size(); j++) { EditorHelp::get_doc_data()->add_doc(docs[j]); } diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index bf118b8e16..65101792b7 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -546,6 +546,12 @@ void EditorNode::_update_from_settings() { RS::get_singleton()->decals_set_filter(RS::DecalFilter(int(GLOBAL_GET("rendering/textures/decals/filter")))); RS::get_singleton()->light_projectors_set_filter(RS::LightProjectorFilter(int(GLOBAL_GET("rendering/textures/light_projectors/filter")))); + + SceneTree *tree = get_tree(); + tree->set_debug_collisions_color(GLOBAL_GET("debug/shapes/collision/shape_color")); + tree->set_debug_collision_contact_color(GLOBAL_GET("debug/shapes/collision/contact_color")); + tree->set_debug_navigation_color(GLOBAL_GET("debug/shapes/navigation/geometry_color")); + tree->set_debug_navigation_disabled_color(GLOBAL_GET("debug/shapes/navigation/disabled_geometry_color")); } void EditorNode::_select_default_main_screen_plugin() { @@ -1885,6 +1891,7 @@ void EditorNode::_dialog_action(String p_file) { case FILE_CLOSE: case FILE_CLOSE_ALL_AND_QUIT: case FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER: + case FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT: case SCENE_TAB_CLOSE: case FILE_SAVE_SCENE: case FILE_SAVE_AS_SCENE: { @@ -2524,17 +2531,23 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) { _scene_tab_closed(editor_data.get_edited_scene()); } break; case FILE_CLOSE_ALL_AND_QUIT: - case FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER: { + case FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER: + case FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT: { if (!p_confirmed) { tab_closing = _next_unsaved_scene(false); _scene_tab_changed(tab_closing); - if (unsaved_cache || p_option == FILE_CLOSE_ALL_AND_QUIT || p_option == FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER) { + if (unsaved_cache || p_option == FILE_CLOSE_ALL_AND_QUIT || p_option == FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER || p_option == FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT) { Node *scene_root = editor_data.get_edited_scene_root(tab_closing); if (scene_root) { String scene_filename = scene_root->get_scene_file_path(); - save_confirmation->get_ok_button()->set_text(TTR("Save & Close")); - save_confirmation->set_text(vformat(TTR("Save changes to '%s' before closing?"), !scene_filename.is_empty() ? scene_filename : "unsaved scene")); + if (p_option == FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT) { + save_confirmation->get_ok_button()->set_text(TTR("Save & Reload")); + save_confirmation->set_text(vformat(TTR("Save changes to '%s' before reloading?"), !scene_filename.is_empty() ? scene_filename : "unsaved scene")); + } else { + save_confirmation->get_ok_button()->set_text(TTR("Save & Quit")); + save_confirmation->set_text(vformat(TTR("Save changes to '%s' before closing?"), !scene_filename.is_empty() ? scene_filename : "unsaved scene")); + } save_confirmation->popup_centered(); break; } @@ -2820,11 +2833,9 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) { case FILE_EXPLORE_ANDROID_BUILD_TEMPLATES: { OS::get_singleton()->shell_open("file://" + ProjectSettings::get_singleton()->get_resource_path().plus_file("android")); } break; - case RUN_RELOAD_CURRENT_PROJECT: { - restart_editor(); - } break; case FILE_QUIT: - case RUN_PROJECT_MANAGER: { + case RUN_PROJECT_MANAGER: + case RELOAD_CURRENT_PROJECT: { if (!p_confirmed) { bool save_each = EDITOR_GET("interface/editor/save_each_scene_on_quit"); if (_next_unsaved_scene(!save_each) == -1) { @@ -2832,7 +2843,13 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) { break; } else { if (save_each) { - _menu_option_confirm(p_option == FILE_QUIT ? FILE_CLOSE_ALL_AND_QUIT : FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER, false); + if (p_option == RELOAD_CURRENT_PROJECT) { + _menu_option_confirm(FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT, false); + } else if (p_option == FILE_QUIT) { + _menu_option_confirm(FILE_CLOSE_ALL_AND_QUIT, false); + } else { + _menu_option_confirm(FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER, false); + } } else { String unsaved_scenes; int i = _next_unsaved_scene(true, 0); @@ -2840,9 +2857,13 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) { unsaved_scenes += "\n " + editor_data.get_edited_scene_root(i)->get_scene_file_path(); i = _next_unsaved_scene(true, ++i); } - - save_confirmation->get_ok_button()->set_text(TTR("Save & Quit")); - save_confirmation->set_text((p_option == FILE_QUIT ? TTR("Save changes to the following scene(s) before quitting?") : TTR("Save changes to the following scene(s) before opening Project Manager?")) + unsaved_scenes); + if (p_option == RELOAD_CURRENT_PROJECT) { + save_confirmation->get_ok_button()->set_text(TTR("Save & Reload")); + save_confirmation->set_text(TTR("Save changes to the following scene(s) before reloading?") + unsaved_scenes); + } else { + save_confirmation->get_ok_button()->set_text(TTR("Save & Quit")); + save_confirmation->set_text((p_option == FILE_QUIT ? TTR("Save changes to the following scene(s) before quitting?") : TTR("Save changes to the following scene(s) before opening Project Manager?")) + unsaved_scenes); + } save_confirmation->popup_centered(); } } @@ -3039,6 +3060,7 @@ void EditorNode::_discard_changes(const String &p_str) { switch (current_option) { case FILE_CLOSE_ALL_AND_QUIT: case FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER: + case FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT: case FILE_CLOSE: case FILE_CLOSE_OTHERS: case FILE_CLOSE_RIGHT: @@ -3055,13 +3077,19 @@ void EditorNode::_discard_changes(const String &p_str) { _remove_scene(tab_closing); _update_scene_tabs(); - if (current_option == FILE_CLOSE_ALL_AND_QUIT || current_option == FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER) { + if (current_option == FILE_CLOSE_ALL_AND_QUIT || current_option == FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER || current_option == FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT) { // If restore tabs is enabled, reopen the scene that has just been closed, so it's remembered properly. if (bool(EDITOR_GET("interface/scene_tabs/restore_scenes_on_load"))) { _menu_option_confirm(FILE_OPEN_PREV, true); } if (_next_unsaved_scene(false) == -1) { - current_option = current_option == FILE_CLOSE_ALL_AND_QUIT ? FILE_QUIT : RUN_PROJECT_MANAGER; + if (current_option == FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT) { + current_option = RELOAD_CURRENT_PROJECT; + } else if (current_option == FILE_CLOSE_ALL_AND_QUIT) { + current_option = FILE_QUIT; + } else { + current_option = RUN_PROJECT_MANAGER; + } _discard_changes(); } else { _menu_option_confirm(current_option, false); @@ -3098,6 +3126,9 @@ void EditorNode::_discard_changes(const String &p_str) { Error err = OS::get_singleton()->create_instance(args); ERR_FAIL_COND(err); } break; + case RELOAD_CURRENT_PROJECT: { + restart_editor(); + } break; } } @@ -6463,7 +6494,7 @@ EditorNode::EditorNode() { tool_menu->add_item(TTR("Orphan Resource Explorer..."), TOOLS_ORPHAN_RESOURCES); p->add_separator(); - p->add_shortcut(ED_SHORTCUT("editor/reload_current_project", TTR("Reload Current Project")), RUN_RELOAD_CURRENT_PROJECT); + p->add_shortcut(ED_SHORTCUT("editor/reload_current_project", TTR("Reload Current Project")), RELOAD_CURRENT_PROJECT); ED_SHORTCUT_AND_COMMAND("editor/quit_to_project_list", TTR("Quit to Project List"), KeyModifierMask::CMD + KeyModifierMask::SHIFT + Key::Q); ED_SHORTCUT_OVERRIDE("editor/quit_to_project_list", "macos", KeyModifierMask::SHIFT + KeyModifierMask::ALT + Key::Q); p->add_shortcut(ED_GET_SHORTCUT("editor/quit_to_project_list"), RUN_PROJECT_MANAGER, true); diff --git a/editor/editor_node.h b/editor/editor_node.h index 0b6dbaec49..0c9df16b2e 100644 --- a/editor/editor_node.h +++ b/editor/editor_node.h @@ -153,6 +153,7 @@ private: FILE_CLOSE_ALL, FILE_CLOSE_ALL_AND_QUIT, FILE_CLOSE_ALL_AND_RUN_PROJECT_MANAGER, + FILE_CLOSE_ALL_AND_RELOAD_CURRENT_PROJECT, FILE_QUIT, FILE_EXTERNAL_OPEN_SCENE, EDIT_UNDO, @@ -169,7 +170,7 @@ private: RUN_PLAY_CUSTOM_SCENE, RUN_SETTINGS, RUN_USER_DATA_FOLDER, - RUN_RELOAD_CURRENT_PROJECT, + RELOAD_CURRENT_PROJECT, RUN_PROJECT_MANAGER, RUN_VCS_METADATA, RUN_VCS_SETTINGS, diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp index 5057fc7531..1364f7891e 100644 --- a/editor/editor_settings.cpp +++ b/editor/editor_settings.cpp @@ -711,7 +711,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) { EDITOR_SETTING(Variant::INT, PROPERTY_HINT_RANGE, "network/debug/remote_port", 6007, "1,65535,1") // SSL - EDITOR_SETTING(Variant::STRING, PROPERTY_HINT_GLOBAL_FILE, "network/ssl/editor_ssl_certificates", _SYSTEM_CERTS_PATH, "*.crt,*.pem") + EDITOR_SETTING_USAGE(Variant::STRING, PROPERTY_HINT_GLOBAL_FILE, "network/ssl/editor_ssl_certificates", _SYSTEM_CERTS_PATH, "*.crt,*.pem", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED); // Profiler _initial_set("debugger/profiler_frame_history_size", 600); diff --git a/editor/editor_spin_slider.cpp b/editor/editor_spin_slider.cpp index 9bf3c4c590..32d28cd3a7 100644 --- a/editor/editor_spin_slider.cpp +++ b/editor/editor_spin_slider.cpp @@ -81,7 +81,7 @@ void EditorSpinSlider::gui_input(const Ref<InputEvent> &p_event) { if (grabbing_spinner_attempt) { if (grabbing_spinner) { Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE); - Input::get_singleton()->warp_mouse_position(grabbing_spinner_mouse_pos); + Input::get_singleton()->warp_mouse(grabbing_spinner_mouse_pos); update(); } else { _focus_entered(); @@ -414,7 +414,7 @@ void EditorSpinSlider::_draw_spin_slider() { grabber->set_position(get_global_position() + (grabber_rect.get_center() - grabber->get_size() * 0.5) * scale); if (mousewheel_over_grabber) { - Input::get_singleton()->warp_mouse_position(grabber->get_position() + grabber_rect.size); + Input::get_singleton()->warp_mouse(grabber->get_position() + grabber_rect.size); } grabber_range = width; diff --git a/editor/editor_themes.cpp b/editor/editor_themes.cpp index 4bd4e073d7..1fea759a90 100644 --- a/editor/editor_themes.cpp +++ b/editor/editor_themes.cpp @@ -635,7 +635,8 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) { style_tab_selected->set_border_width_all(0); style_tab_selected->set_border_width(SIDE_TOP, Math::round(2 * EDSCALE)); // Make the highlight line prominent, but not too prominent as to not be distracting. - style_tab_selected->set_border_color(dark_color_2.lerp(accent_color, 0.75)); + Color tab_highlight = dark_color_2.lerp(accent_color, 0.75); + style_tab_selected->set_border_color(tab_highlight); // Don't round the top corners to avoid creating a small blank space between the tabs and the main panel. // This also makes the top highlight look better. style_tab_selected->set_corner_radius_all(0); @@ -1079,17 +1080,19 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) { theme->set_stylebox("tab_selected", "TabBar", style_tab_selected); theme->set_stylebox("tab_unselected", "TabBar", style_tab_unselected); theme->set_stylebox("tab_disabled", "TabBar", style_tab_disabled); + theme->set_stylebox("button_pressed", "TabBar", style_menu); + theme->set_stylebox("button_highlight", "TabBar", style_menu); + theme->set_stylebox("SceneTabFG", "EditorStyles", style_tab_selected); + theme->set_stylebox("SceneTabBG", "EditorStyles", style_tab_unselected); theme->set_color("font_selected_color", "TabContainer", font_color); theme->set_color("font_unselected_color", "TabContainer", font_disabled_color); theme->set_color("font_selected_color", "TabBar", font_color); theme->set_color("font_unselected_color", "TabBar", font_disabled_color); + theme->set_color("drop_mark_color", "TabContainer", tab_highlight); + theme->set_color("drop_mark_color", "TabBar", tab_highlight); theme->set_icon("menu", "TabContainer", theme->get_icon(SNAME("GuiTabMenu"), SNAME("EditorIcons"))); theme->set_icon("menu_highlight", "TabContainer", theme->get_icon(SNAME("GuiTabMenuHl"), SNAME("EditorIcons"))); - theme->set_stylebox("SceneTabFG", "EditorStyles", style_tab_selected); - theme->set_stylebox("SceneTabBG", "EditorStyles", style_tab_unselected); theme->set_icon("close", "TabBar", theme->get_icon(SNAME("GuiClose"), SNAME("EditorIcons"))); - theme->set_stylebox("button_pressed", "TabBar", style_menu); - theme->set_stylebox("button_highlight", "TabBar", style_menu); theme->set_icon("increment", "TabContainer", theme->get_icon(SNAME("GuiScrollArrowRight"), SNAME("EditorIcons"))); theme->set_icon("decrement", "TabContainer", theme->get_icon(SNAME("GuiScrollArrowLeft"), SNAME("EditorIcons"))); theme->set_icon("increment", "TabBar", theme->get_icon(SNAME("GuiScrollArrowRight"), SNAME("EditorIcons"))); @@ -1098,6 +1101,8 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) { theme->set_icon("decrement_highlight", "TabBar", theme->get_icon(SNAME("GuiScrollArrowLeftHl"), SNAME("EditorIcons"))); theme->set_icon("increment_highlight", "TabContainer", theme->get_icon(SNAME("GuiScrollArrowRightHl"), SNAME("EditorIcons"))); theme->set_icon("decrement_highlight", "TabContainer", theme->get_icon(SNAME("GuiScrollArrowLeftHl"), SNAME("EditorIcons"))); + theme->set_icon("drop_mark", "TabContainer", theme->get_icon(SNAME("GuiTabDropMark"), SNAME("EditorIcons"))); + theme->set_icon("drop_mark", "TabBar", theme->get_icon(SNAME("GuiTabDropMark"), SNAME("EditorIcons"))); theme->set_constant("hseparation", "TabBar", 4 * EDSCALE); // Content of each tab diff --git a/editor/filesystem_dock.cpp b/editor/filesystem_dock.cpp index 2100a787c8..ee7ed77957 100644 --- a/editor/filesystem_dock.cpp +++ b/editor/filesystem_dock.cpp @@ -224,6 +224,19 @@ void FileSystemDock::_update_tree(const Vector<String> &p_uncollapsed_paths, boo favorites->set_collapsed(p_uncollapsed_paths.find("Favorites") < 0); Vector<String> favorite_paths = EditorSettings::get_singleton()->get_favorites(); + + DirAccessRef da = DirAccess::create(DirAccess::ACCESS_RESOURCES); + bool fav_changed = false; + for (int i = favorite_paths.size() - 1; i >= 0; i--) { + if (!da->dir_exists(favorite_paths[i])) { + favorite_paths.remove_at(i); + fav_changed = true; + } + } + if (fav_changed) { + EditorSettings::get_singleton()->set_favorites(favorite_paths); + } + for (int i = 0; i < favorite_paths.size(); i++) { String fave = favorite_paths[i]; if (!fave.begins_with("res://")) { diff --git a/editor/icons/GuiTabDropMark.svg b/editor/icons/GuiTabDropMark.svg new file mode 100644 index 0000000000..c85b165c71 --- /dev/null +++ b/editor/icons/GuiTabDropMark.svg @@ -0,0 +1 @@ +<svg height="32" viewBox="0 0 16 32" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m5 2h6v30h-6z" fill="#fff"/></svg> diff --git a/editor/import/resource_importer_texture.cpp b/editor/import/resource_importer_texture.cpp index 8d6db7d1e0..e2fa624fc6 100644 --- a/editor/import/resource_importer_texture.cpp +++ b/editor/import/resource_importer_texture.cpp @@ -171,6 +171,11 @@ bool ResourceImporterTexture::get_option_visibility(const String &p_path, const if (compress_mode < COMPRESS_VRAM_COMPRESSED) { return false; } + } else if (p_option == "compress/normal_map") { + int compress_mode = int(p_options["compress/mode"]); + if (compress_mode == COMPRESS_LOSSLESS) { + return false; + } } else if (p_option == "mipmaps/limit") { return p_options["mipmaps/generate"]; diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp index d713e70251..764f467192 100644 --- a/editor/plugins/canvas_item_editor_plugin.cpp +++ b/editor/plugins/canvas_item_editor_plugin.cpp @@ -4324,8 +4324,8 @@ void CanvasItemEditor::_popup_callback(int p_op) { undo_redo->add_do_method(this, "emit_signal", "item_lock_status_changed"); undo_redo->add_undo_method(this, "emit_signal", "item_lock_status_changed"); } - undo_redo->add_do_method(viewport, "update", Variant()); - undo_redo->add_undo_method(viewport, "update", Variant()); + undo_redo->add_do_method(viewport, "update"); + undo_redo->add_undo_method(viewport, "update"); undo_redo->commit_action(); } break; case UNLOCK_SELECTED: { @@ -4346,8 +4346,8 @@ void CanvasItemEditor::_popup_callback(int p_op) { undo_redo->add_do_method(this, "emit_signal", "item_lock_status_changed"); undo_redo->add_undo_method(this, "emit_signal", "item_lock_status_changed"); } - undo_redo->add_do_method(viewport, "update", Variant()); - undo_redo->add_undo_method(viewport, "update", Variant()); + undo_redo->add_do_method(viewport, "update"); + undo_redo->add_undo_method(viewport, "update"); undo_redo->commit_action(); } break; case GROUP_SELECTED: { @@ -4368,8 +4368,8 @@ void CanvasItemEditor::_popup_callback(int p_op) { undo_redo->add_do_method(this, "emit_signal", "item_group_status_changed"); undo_redo->add_undo_method(this, "emit_signal", "item_group_status_changed"); } - undo_redo->add_do_method(viewport, "update", Variant()); - undo_redo->add_undo_method(viewport, "update", Variant()); + undo_redo->add_do_method(viewport, "update"); + undo_redo->add_undo_method(viewport, "update"); undo_redo->commit_action(); } break; case UNGROUP_SELECTED: { @@ -4390,8 +4390,8 @@ void CanvasItemEditor::_popup_callback(int p_op) { undo_redo->add_do_method(this, "emit_signal", "item_group_status_changed"); undo_redo->add_undo_method(this, "emit_signal", "item_group_status_changed"); } - undo_redo->add_do_method(viewport, "update", Variant()); - undo_redo->add_undo_method(viewport, "update", Variant()); + undo_redo->add_do_method(viewport, "update"); + undo_redo->add_undo_method(viewport, "update"); undo_redo->commit_action(); } break; diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp index 52e60b606c..ea119a33fa 100644 --- a/editor/plugins/node_3d_editor_plugin.cpp +++ b/editor/plugins/node_3d_editor_plugin.cpp @@ -205,7 +205,7 @@ void ViewportRotationControl::gui_input(const Ref<InputEvent> &p_event) { orbiting = false; if (Input::get_singleton()->get_mouse_mode() == Input::MOUSE_MODE_CAPTURED) { Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE); - Input::get_singleton()->warp_mouse_position(orbiting_mouse_start); + Input::get_singleton()->warp_mouse(orbiting_mouse_start); } } } diff --git a/editor/plugins/script_editor_plugin.cpp b/editor/plugins/script_editor_plugin.cpp index 2da5978fab..bbaf2bef98 100644 --- a/editor/plugins/script_editor_plugin.cpp +++ b/editor/plugins/script_editor_plugin.cpp @@ -1348,7 +1348,7 @@ void ScriptEditor::_menu_option(int p_option) { } if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); if (EditorHelp::get_doc_data()->has_doc(doc.name)) { @@ -1361,7 +1361,7 @@ void ScriptEditor::_menu_option(int p_option) { EditorNode::get_singleton()->save_resource_as(resource); if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); EditorHelp::get_doc_data()->add_doc(doc); @@ -2464,7 +2464,7 @@ void ScriptEditor::save_current_script() { } if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); if (EditorHelp::get_doc_data()->has_doc(doc.name)) { @@ -2486,7 +2486,7 @@ void ScriptEditor::save_current_script() { } if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); EditorHelp::get_doc_data()->add_doc(doc); @@ -2537,7 +2537,7 @@ void ScriptEditor::save_all_scripts() { } if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); if (EditorHelp::get_doc_data()->has_doc(doc.name)) { @@ -2549,7 +2549,7 @@ void ScriptEditor::save_all_scripts() { EditorNode::get_singleton()->save_resource(edited_res); //external script, save it if (script != nullptr) { - const Vector<DocData::ClassDoc> &documentations = script->get_documentation(); + Vector<DocData::ClassDoc> documentations = script->get_documentation(); for (int j = 0; j < documentations.size(); j++) { const DocData::ClassDoc &doc = documentations.get(j); EditorHelp::get_doc_data()->add_doc(doc); diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp index 30ca1c605f..c1b0a32fc7 100644 --- a/editor/plugins/script_text_editor.cpp +++ b/editor/plugins/script_text_editor.cpp @@ -684,12 +684,12 @@ void ScriptEditor::_update_modified_scripts_for_external_editor(Ref<Script> p_fo } } -void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) { +void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force) { ScriptTextEditor *ste = (ScriptTextEditor *)p_ud; ste->_code_complete_script(p_code, r_options, r_force); } -void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) { +void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force) { if (color_panel->is_visible()) { return; } @@ -771,7 +771,7 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c _goto_line(p_row); switch (result.type) { - case ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION: { + case ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION: { if (result.script.is_valid()) { emit_signal(SNAME("request_open_script_at_line"), result.script, result.location - 1); } else { @@ -779,10 +779,10 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c goto_line_centered(result.location - 1); } } break; - case ScriptLanguage::LookupResult::RESULT_CLASS: { + case ScriptLanguage::LOOKUP_RESULT_CLASS: { emit_signal(SNAME("go_to_help"), "class_name:" + result.class_name); } break; - case ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT: { + case ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT: { StringName cname = result.class_name; bool success; while (true) { @@ -798,11 +798,11 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c emit_signal(SNAME("go_to_help"), "class_constant:" + result.class_name + ":" + result.class_member); } break; - case ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY: { + case ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY: { emit_signal(SNAME("go_to_help"), "class_property:" + result.class_name + ":" + result.class_member); } break; - case ScriptLanguage::LookupResult::RESULT_CLASS_METHOD: { + case ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD: { StringName cname = result.class_name; while (true) { @@ -817,7 +817,7 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c emit_signal(SNAME("go_to_help"), "class_method:" + result.class_name + ":" + result.class_member); } break; - case ScriptLanguage::LookupResult::RESULT_CLASS_ENUM: { + case ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM: { StringName cname = result.class_name; StringName success; while (true) { @@ -833,9 +833,11 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c emit_signal(SNAME("go_to_help"), "class_enum:" + result.class_name + ":" + result.class_member); } break; - case ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE: { + case ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE: { emit_signal(SNAME("go_to_help"), "class_global:" + result.class_name + ":" + result.class_member); } break; + default: { + } } } else if (ProjectSettings::get_singleton()->has_autoload(p_symbol)) { // Check for Autoload scenes. diff --git a/editor/plugins/script_text_editor.h b/editor/plugins/script_text_editor.h index 1e2284b403..5c3a66404e 100644 --- a/editor/plugins/script_text_editor.h +++ b/editor/plugins/script_text_editor.h @@ -162,8 +162,8 @@ protected: void _update_bookmark_list(); void _bookmark_item_pressed(int p_idx); - static void _code_complete_scripts(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force); - void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force); + static void _code_complete_scripts(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force); + void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force); void _load_theme_settings(); void _set_theme_for_script(); diff --git a/editor/plugins/shader_editor_plugin.cpp b/editor/plugins/shader_editor_plugin.cpp index dbe6ca192c..070f1fac1e 100644 --- a/editor/plugins/shader_editor_plugin.cpp +++ b/editor/plugins/shader_editor_plugin.cpp @@ -222,7 +222,7 @@ static ShaderLanguage::DataType _get_global_variable_type(const StringName &p_va return (ShaderLanguage::DataType)RS::global_variable_type_get_shader_datatype(gvt); } -void ShaderTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) { +void ShaderTextEditor::_code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) { _check_shader_mode(); ShaderLanguage sl; diff --git a/editor/plugins/shader_editor_plugin.h b/editor/plugins/shader_editor_plugin.h index b1391e4f66..600b14362e 100644 --- a/editor/plugins/shader_editor_plugin.h +++ b/editor/plugins/shader_editor_plugin.h @@ -65,7 +65,7 @@ protected: static void _bind_methods(); virtual void _load_theme_settings() override; - virtual void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) override; + virtual void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) override; public: virtual void _validate_script() override; diff --git a/editor/project_manager.cpp b/editor/project_manager.cpp index d011d7a7e7..cd95f97286 100644 --- a/editor/project_manager.cpp +++ b/editor/project_manager.cpp @@ -2872,10 +2872,17 @@ ProjectManager::ProjectManager() { if (scale_factor > 1.0) { Vector2i window_size = DisplayServer::get_singleton()->window_get_size(); Vector2i screen_size = DisplayServer::get_singleton()->screen_get_size(); - window_size *= scale_factor; + Vector2i screen_position = DisplayServer::get_singleton()->screen_get_position(); + + // Consider the editor display scale. + window_size.x = round((float)window_size.x * scale_factor); + window_size.y = round((float)window_size.y * scale_factor); + + // Make the window centered on the screen. Vector2i window_position; - window_position.x = (screen_size.x - window_size.x) / 2; - window_position.y = (screen_size.y - window_size.y) / 2; + window_position.x = screen_position.x + (screen_size.x - window_size.x) / 2; + window_position.y = screen_position.y + (screen_size.y - window_size.y) / 2; + DisplayServer::get_singleton()->window_set_size(window_size); DisplayServer::get_singleton()->window_set_position(window_position); } diff --git a/editor/scene_tree_editor.cpp b/editor/scene_tree_editor.cpp index 3b8c540592..44eb5c670d 100644 --- a/editor/scene_tree_editor.cpp +++ b/editor/scene_tree_editor.cpp @@ -96,8 +96,8 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i if (n->is_class("CanvasItem") || n->is_class("Node3D")) { undo_redo->add_do_method(n, "remove_meta", "_edit_lock_"); undo_redo->add_undo_method(n, "set_meta", "_edit_lock_", true); - undo_redo->add_do_method(this, "_update_tree", Variant()); - undo_redo->add_undo_method(this, "_update_tree", Variant()); + undo_redo->add_do_method(this, "_update_tree"); + undo_redo->add_undo_method(this, "_update_tree"); undo_redo->add_do_method(this, "emit_signal", "node_changed"); undo_redo->add_undo_method(this, "emit_signal", "node_changed"); } @@ -114,8 +114,8 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i if (n->is_class("CanvasItem") || n->is_class("Node3D")) { undo_redo->add_do_method(n, "remove_meta", "_edit_group_"); undo_redo->add_undo_method(n, "set_meta", "_edit_group_", true); - undo_redo->add_do_method(this, "_update_tree", Variant()); - undo_redo->add_undo_method(this, "_update_tree", Variant()); + undo_redo->add_do_method(this, "_update_tree"); + undo_redo->add_undo_method(this, "_update_tree"); undo_redo->add_do_method(this, "emit_signal", "node_changed"); undo_redo->add_undo_method(this, "emit_signal", "node_changed"); } diff --git a/editor/script_create_dialog.cpp b/editor/script_create_dialog.cpp index baafef8639..72f77c859b 100644 --- a/editor/script_create_dialog.cpp +++ b/editor/script_create_dialog.cpp @@ -106,15 +106,7 @@ static Vector<String> _get_hierarchy(String p_class_name) { void ScriptCreateDialog::_notification(int p_what) { switch (p_what) { - case NOTIFICATION_ENTER_TREE: - case NOTIFICATION_THEME_CHANGED: { - for (int i = 0; i < ScriptServer::get_language_count(); i++) { - Ref<Texture2D> language_icon = get_theme_icon(ScriptServer::get_language(i)->get_type(), SNAME("EditorIcons")); - if (language_icon.is_valid()) { - language_menu->set_item_icon(i, language_icon); - } - } - + case NOTIFICATION_ENTER_TREE: { String last_language = EditorSettings::get_singleton()->get_project_metadata("script_setup", "last_selected_language", ""); if (!last_language.is_empty()) { for (int i = 0; i < language_menu->get_item_count(); i++) { @@ -127,9 +119,15 @@ void ScriptCreateDialog::_notification(int p_what) { } else { language_menu->select(default_language); } - if (EditorSettings::get_singleton()->has_meta("script_setup/use_script_templates")) { - is_using_templates = bool(EditorSettings::get_singleton()->get_meta("script_setup/use_script_templates")); - use_templates->set_pressed(is_using_templates); + + [[fallthrough]]; + } + case NOTIFICATION_THEME_CHANGED: { + for (int i = 0; i < ScriptServer::get_language_count(); i++) { + Ref<Texture2D> language_icon = get_theme_icon(ScriptServer::get_language(i)->get_type(), SNAME("EditorIcons")); + if (language_icon.is_valid()) { + language_menu->set_item_icon(i, language_icon); + } } path_button->set_icon(get_theme_icon(SNAME("Folder"), SNAME("EditorIcons"))); @@ -332,13 +330,8 @@ void ScriptCreateDialog::_template_changed(int p_template) { dic_templates_project[parent_name->get_text()] = sinfo.get_hash(); EditorSettings::get_singleton()->set_project_metadata("script_setup", "templates_dictionary", dic_templates_project); } else { - // Save template into to editor dictionary (not a project template). - Dictionary dic_templates; - if (EditorSettings::get_singleton()->has_meta("script_setup/templates_dictionary")) { - dic_templates = (Dictionary)EditorSettings::get_singleton()->get_meta("script_setup/templates_dictionary"); - } - dic_templates[parent_name->get_text()] = sinfo.get_hash(); - EditorSettings::get_singleton()->set_meta("script_setup/templates_dictionary", dic_templates); + // Save template info to editor dictionary (not a project template). + templates_dictionary[parent_name->get_text()] = sinfo.get_hash(); // Remove template from project dictionary as we last used an editor level template. Dictionary dic_templates_project = EditorSettings::get_singleton()->get_project_metadata("script_setup", "templates_dictionary", Dictionary()); if (dic_templates_project.has(parent_name->get_text())) { @@ -479,7 +472,6 @@ void ScriptCreateDialog::_built_in_pressed() { void ScriptCreateDialog::_use_template_pressed() { is_using_templates = use_templates->is_pressed(); - EditorSettings::get_singleton()->set_meta("script_setup/use_script_templates", is_using_templates); _update_dialog(); } @@ -597,10 +589,6 @@ void ScriptCreateDialog::_update_template_menu() { if (is_language_using_templates) { // Get the latest templates used for each type of node from project settings then global settings. Dictionary last_local_templates = EditorSettings::get_singleton()->get_project_metadata("script_setup", "templates_dictionary", Dictionary()); - Dictionary last_global_templates; - if (EditorSettings::get_singleton()->has_meta("script_setup/templates_dictionary")) { - last_global_templates = (Dictionary)EditorSettings::get_singleton()->get_meta("script_setup/templates_dictionary"); - } String inherits_base_type = parent_name->get_text(); // If it inherits from a script, get its parent class first. @@ -655,7 +643,7 @@ void ScriptCreateDialog::_update_template_menu() { // Check for last used template for this node in project settings then in global settings. if (last_local_templates.has(parent_name->get_text()) && t.get_hash() == String(last_local_templates[parent_name->get_text()])) { last_used_template = id; - } else if (last_used_template == -1 && last_global_templates.has(parent_name->get_text()) && t.get_hash() == String(last_global_templates[parent_name->get_text()])) { + } else if (last_used_template == -1 && templates_dictionary.has(parent_name->get_text()) && t.get_hash() == String(templates_dictionary[parent_name->get_text()])) { last_used_template = id; } t.id = id; diff --git a/editor/script_create_dialog.h b/editor/script_create_dialog.h index d7c43f322c..e9f634e2c0 100644 --- a/editor/script_create_dialog.h +++ b/editor/script_create_dialog.h @@ -83,6 +83,7 @@ class ScriptCreateDialog : public ConfirmationDialog { int current_language; int default_language; bool re_check_path = false; + Dictionary templates_dictionary; Control *path_controls[2]; Control *name_controls[2]; diff --git a/modules/gdscript/editor_templates/CharacterBody2D/basic_movement.gd b/modules/gdscript/editor_templates/CharacterBody2D/basic_movement.gd index 34b5ba45b7..a379d915a9 100644 --- a/modules/gdscript/editor_templates/CharacterBody2D/basic_movement.gd +++ b/modules/gdscript/editor_templates/CharacterBody2D/basic_movement.gd @@ -2,8 +2,9 @@ extends _BASE_ -const SPEED: float = 300.0 -const JUMP_VELOCITY: float = -400.0 + +const SPEED = 300.0 +const JUMP_VELOCITY = -400.0 # Get the gravity from the project settings to be synced with RigidDynamicBody nodes. var gravity: int = ProjectSettings.get_setting("physics/2d/default_gravity") diff --git a/modules/gdscript/editor_templates/CharacterBody3D/basic_movement.gd b/modules/gdscript/editor_templates/CharacterBody3D/basic_movement.gd index cbc9cf1064..360b199e56 100644 --- a/modules/gdscript/editor_templates/CharacterBody3D/basic_movement.gd +++ b/modules/gdscript/editor_templates/CharacterBody3D/basic_movement.gd @@ -2,8 +2,9 @@ extends _BASE_ -const SPEED: float = 5.0 -const JUMP_VELOCITY: float = 4.5 + +const SPEED = 5.0 +const JUMP_VELOCITY = 4.5 # Get the gravity from the project settings to be synced with RigidDynamicBody nodes. var gravity: float = ProjectSettings.get_setting("physics/3d/default_gravity") diff --git a/modules/gdscript/editor_templates/EditorPlugin/plugin.gd b/modules/gdscript/editor_templates/EditorPlugin/plugin.gd index 8614bb8b17..b27b3e5655 100644 --- a/modules/gdscript/editor_templates/EditorPlugin/plugin.gd +++ b/modules/gdscript/editor_templates/EditorPlugin/plugin.gd @@ -2,10 +2,12 @@ @tool extends EditorPlugin + func _enter_tree() -> void: - # Initialization of the plugin goes here. - pass + # Initialization of the plugin goes here. + pass + func _exit_tree() -> void: - # Clean-up of the plugin goes here. - pass + # Clean-up of the plugin goes here. + pass diff --git a/modules/gdscript/editor_templates/EditorScript/basic_editor_script.gd b/modules/gdscript/editor_templates/EditorScript/basic_editor_script.gd index fdb174c7ed..fdb8550d43 100644 --- a/modules/gdscript/editor_templates/EditorScript/basic_editor_script.gd +++ b/modules/gdscript/editor_templates/EditorScript/basic_editor_script.gd @@ -2,6 +2,7 @@ @tool extends EditorScript + +# Called when the script is executed (using File -> Run in Script Editor). func _run() -> void: - # Called when the script is executed (using File -> Run in Script Editor). - pass + pass diff --git a/modules/gdscript/editor_templates/Node/default.gd b/modules/gdscript/editor_templates/Node/default.gd index ee5c0b99cc..cb96a21537 100644 --- a/modules/gdscript/editor_templates/Node/default.gd +++ b/modules/gdscript/editor_templates/Node/default.gd @@ -2,10 +2,12 @@ extends _BASE_ + # Called when the node enters the scene tree for the first time. func _ready() -> void: pass # Replace with function body. + # Called every frame. 'delta' is the elapsed time since the previous frame. func _process(delta: float) -> void: pass diff --git a/modules/gdscript/editor_templates/VisualShaderNodeCustom/basic.gd b/modules/gdscript/editor_templates/VisualShaderNodeCustom/basic.gd index cf6d68333d..283a95d3b4 100644 --- a/modules/gdscript/editor_templates/VisualShaderNodeCustom/basic.gd +++ b/modules/gdscript/editor_templates/VisualShaderNodeCustom/basic.gd @@ -1,38 +1,50 @@ # meta-description: Visual shader's node plugin template @tool -extends _BASE_ class_name VisualShaderNode_CLASS_ +extends _BASE_ + func _get_name() -> String: return "_CLASS_" + func _get_category() -> String: return "" + func _get_description() -> String: return "" + func _get_return_icon_type() -> int: return PORT_TYPE_SCALAR + func _get_input_port_count() -> int: return 0 + func _get_input_port_name(port: int) -> String: return "" + func _get_input_port_type(port: int) -> int: return PORT_TYPE_SCALAR + func _get_output_port_count() -> int: return 1 + func _get_output_port_name(port: int) -> String: return "result" + func _get_output_port_type(port: int) -> int: return PORT_TYPE_SCALAR -func _get_code(input_vars: Array[String], output_vars: Array[String], mode: int, type: int) -> String: + +func _get_code(input_vars: Array[String], output_vars: Array[String], + mode: int, type: int) -> String: return output_vars[0] + " = 0.0;" diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h index 30e60e2b91..f7fa967883 100644 --- a/modules/gdscript/gdscript.h +++ b/modules/gdscript/gdscript.h @@ -212,7 +212,7 @@ public: virtual void update_exports() override; #ifdef TOOLS_ENABLED - virtual const Vector<DocData::ClassDoc> &get_documentation() const override { + virtual Vector<DocData::ClassDoc> get_documentation() const override { return docs; } #endif // TOOLS_ENABLED @@ -455,7 +455,7 @@ public: virtual bool can_inherit_from_file() const override { return true; } virtual int find_function(const String &p_function, const String &p_code) const override; virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override; - virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) override; + virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) override; #ifdef TOOLS_ENABLED virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) override; #endif diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp index af3d65d4d6..27e1520ab8 100644 --- a/modules/gdscript/gdscript_analyzer.cpp +++ b/modules/gdscript/gdscript_analyzer.cpp @@ -2303,7 +2303,7 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a break; #ifdef DEBUG_ENABLED } else { - if (par_type.builtin_type == Variant::INT && p_call->arguments[i]->get_datatype().builtin_type == Variant::FLOAT) { + if (par_type.builtin_type == Variant::INT && p_call->arguments[i]->get_datatype().builtin_type == Variant::FLOAT && builtin_type != Variant::INT) { parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, p_call->function_name); } #endif diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp index 350962ba1b..4a6e1eb497 100644 --- a/modules/gdscript/gdscript_editor.cpp +++ b/modules/gdscript/gdscript_editor.cpp @@ -68,14 +68,21 @@ Ref<Script> GDScriptLanguage::make_template(const String &p_template, const Stri if (!EDITOR_GET("text_editor/completion/add_type_hints")) { processed_template = processed_template.replace(": int", "") .replace(": String", "") + .replace(": Array[String]", "") .replace(": float", "") .replace(":=", "=") + .replace(" -> String", "") + .replace(" -> int", "") .replace(" -> void", ""); } #else processed_template = processed_template.replace(": int", "") .replace(": String", "") + .replace(": Array[String]", "") .replace(": float", "") + .replace(":=", "=") + .replace(" -> String", "") + .replace(" -> int", "") .replace(" -> void", ""); #endif @@ -637,11 +644,11 @@ static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_functio return arghint; } -static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptCodeCompletionOption> &r_list) { +static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptLanguage::CodeCompletionOption> &r_list) { const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\""; for (int i = 0; i < p_dir->get_file_count(); i++) { - ScriptCodeCompletionOption option(p_dir->get_file_path(i), ScriptCodeCompletionOption::KIND_FILE_PATH); + ScriptLanguage::CodeCompletionOption option(p_dir->get_file_path(i), ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH); option.insert_text = option.display.quote(quote_style); r_list.insert(option.display, option); } @@ -651,29 +658,29 @@ static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String } } -static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, Map<String, ScriptCodeCompletionOption> &r_result) { +static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) { if (p_annotation->name == SNAME("@export_range")) { if (p_argument == 3 || p_argument == 4) { // Slider hint. - ScriptCodeCompletionOption slider1("or_greater", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption slider1("or_greater", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); slider1.insert_text = slider1.display.quote(p_quote_style); r_result.insert(slider1.display, slider1); - ScriptCodeCompletionOption slider2("or_lesser", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption slider2("or_lesser", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); slider2.insert_text = slider2.display.quote(p_quote_style); r_result.insert(slider2.display, slider2); } } else if (p_annotation->name == SNAME("@export_exp_easing")) { if (p_argument == 0 || p_argument == 1) { // Easing hint. - ScriptCodeCompletionOption hint1("attenuation", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption hint1("attenuation", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); hint1.insert_text = hint1.display.quote(p_quote_style); r_result.insert(hint1.display, hint1); - ScriptCodeCompletionOption hint2("inout", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption hint2("inout", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); hint2.insert_text = hint2.display.quote(p_quote_style); r_result.insert(hint2.display, hint2); } } else if (p_annotation->name == SNAME("@export_node_path")) { - ScriptCodeCompletionOption node("Node", ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption node("Node", ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(node.display, node); List<StringName> node_types; ClassDB::get_inheriters_from_class("Node", &node_types); @@ -681,23 +688,23 @@ static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_a if (!ClassDB::is_class_exposed(E)) { continue; } - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } } else if (p_annotation->name == SNAME("@warning_ignore")) { for (int warning_code = 0; warning_code < GDScriptWarning::WARNING_MAX; warning_code++) { - ScriptCodeCompletionOption warning(GDScriptWarning::get_name_from_code((GDScriptWarning::Code)warning_code).to_lower(), ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption warning(GDScriptWarning::get_name_from_code((GDScriptWarning::Code)warning_code).to_lower(), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_result.insert(warning.display, warning); } } } -static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, Map<String, ScriptCodeCompletionOption> &r_result) { +static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) { List<StringName> native_types; ClassDB::get_class_list(&native_types); for (const StringName &E : native_types) { if (ClassDB::is_class_exposed(E) && !Engine::get_singleton()->has_singleton(E)) { - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } } @@ -708,7 +715,7 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio List<StringName> enums; ClassDB::get_enum_list(p_context.current_class->base_type.native_type, &enums); for (const StringName &E : enums) { - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_ENUM); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_ENUM); r_result.insert(option.display, option); } } @@ -719,18 +726,18 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio const GDScriptParser::ClassNode::Member &member = current->members[i]; switch (member.type) { case GDScriptParser::ClassNode::Member::CLASS: { - ScriptCodeCompletionOption option(member.m_class->identifier->name, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } break; case GDScriptParser::ClassNode::Member::ENUM: { if (!p_inherit_only) { - ScriptCodeCompletionOption option(member.m_enum->identifier->name, ScriptCodeCompletionOption::KIND_ENUM); + ScriptLanguage::CodeCompletionOption option(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM); r_result.insert(option.display, option); } } break; case GDScriptParser::ClassNode::Member::CONSTANT: { if (member.constant->get_datatype().is_meta_type && p_context.current_class->outer != nullptr) { - ScriptCodeCompletionOption option(member.constant->identifier->name, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } } break; @@ -746,7 +753,7 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio List<StringName> global_classes; ScriptServer::get_global_class_list(&global_classes); for (const StringName &E : global_classes) { - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } @@ -757,19 +764,19 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio if (!info.is_singleton || info.path.get_extension().to_lower() != "gd") { continue; } - ScriptCodeCompletionOption option(info.name, ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(info.name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } } -static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, Map<String, ScriptCodeCompletionOption> &r_result) { +static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) { for (int i = 0; i < p_suite->locals.size(); i++) { - ScriptCodeCompletionOption option; + ScriptLanguage::CodeCompletionOption option; if (p_suite->locals[i].type == GDScriptParser::SuiteNode::Local::CONSTANT) { - option = ScriptCodeCompletionOption(p_suite->locals[i].name, ScriptCodeCompletionOption::KIND_CONSTANT); + option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); option.default_value = p_suite->locals[i].constant->initializer->reduced_value; } else { - option = ScriptCodeCompletionOption(p_suite->locals[i].name, ScriptCodeCompletionOption::KIND_VARIABLE); + option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE); } r_result.insert(option.display, option); } @@ -778,9 +785,9 @@ static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, } } -static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth); +static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth); -static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) { +static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) { ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT); if (!p_parent_only) { @@ -789,13 +796,13 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, while (clss) { for (int i = 0; i < clss->members.size(); i++) { const GDScriptParser::ClassNode::Member &member = clss->members[i]; - ScriptCodeCompletionOption option; + ScriptLanguage::CodeCompletionOption option; switch (member.type) { case GDScriptParser::ClassNode::Member::VARIABLE: if (p_only_functions || outer || (p_static)) { continue; } - option = ScriptCodeCompletionOption(member.variable->identifier->name, ScriptCodeCompletionOption::KIND_MEMBER); + option = ScriptLanguage::CodeCompletionOption(member.variable->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); break; case GDScriptParser::ClassNode::Member::CONSTANT: if (p_only_functions) { @@ -804,7 +811,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, if (r_result.has(member.constant->identifier->name)) { continue; } - option = ScriptCodeCompletionOption(member.constant->identifier->name, ScriptCodeCompletionOption::KIND_CONSTANT); + option = ScriptLanguage::CodeCompletionOption(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); if (member.constant->initializer) { option.default_value = member.constant->initializer->reduced_value; } @@ -813,25 +820,25 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, if (p_only_functions) { continue; } - option = ScriptCodeCompletionOption(member.m_class->identifier->name, ScriptCodeCompletionOption::KIND_CLASS); + option = ScriptLanguage::CodeCompletionOption(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS); break; case GDScriptParser::ClassNode::Member::ENUM_VALUE: if (p_only_functions) { continue; } - option = ScriptCodeCompletionOption(member.enum_value.identifier->name, ScriptCodeCompletionOption::KIND_CONSTANT); + option = ScriptLanguage::CodeCompletionOption(member.enum_value.identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); break; case GDScriptParser::ClassNode::Member::ENUM: if (p_only_functions) { continue; } - option = ScriptCodeCompletionOption(member.m_enum->identifier->name, ScriptCodeCompletionOption::KIND_ENUM); + option = ScriptLanguage::CodeCompletionOption(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM); break; case GDScriptParser::ClassNode::Member::FUNCTION: if (outer || (p_static && !member.function->is_static) || member.function->identifier->name.operator String().begins_with("@")) { continue; } - option = ScriptCodeCompletionOption(member.function->identifier->name, ScriptCodeCompletionOption::KIND_FUNCTION); + option = ScriptLanguage::CodeCompletionOption(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); if (member.function->parameters.size() > 0) { option.insert_text += "("; } else { @@ -842,7 +849,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, if (p_only_functions || outer) { continue; } - option = ScriptCodeCompletionOption(member.signal->identifier->name, ScriptCodeCompletionOption::KIND_SIGNAL); + option = ScriptLanguage::CodeCompletionOption(member.signal->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL); break; case GDScriptParser::ClassNode::Member::UNDEFINED: break; @@ -862,14 +869,14 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, _find_identifiers_in_base(base_type, p_only_functions, r_result, p_recursion_depth + 1); } -static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) { +static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) { ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT); GDScriptParser::DataType base_type = p_base.type; bool _static = base_type.is_meta_type; if (_static && base_type.kind != GDScriptParser::DataType::BUILTIN) { - ScriptCodeCompletionOption option("new", ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option("new", ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); option.insert_text += "("; r_result.insert(option.display, option); } @@ -889,21 +896,21 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base List<PropertyInfo> members; scr->get_script_property_list(&members); for (const PropertyInfo &E : members) { - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); r_result.insert(option.display, option); } } Map<StringName, Variant> constants; scr->get_constants(&constants); for (const KeyValue<StringName, Variant> &E : constants) { - ScriptCodeCompletionOption option(E.key.operator String(), ScriptCodeCompletionOption::KIND_CONSTANT); + ScriptLanguage::CodeCompletionOption option(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); r_result.insert(option.display, option); } List<MethodInfo> signals; scr->get_script_signal_list(&signals); for (const MethodInfo &E : signals) { - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_SIGNAL); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL); r_result.insert(option.display, option); } } @@ -914,7 +921,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base if (E.name.begins_with("@")) { continue; } - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); if (E.arguments.size()) { option.insert_text += "("; } else { @@ -944,7 +951,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base List<String> constants; ClassDB::get_integer_constant_list(type, &constants); for (const String &E : constants) { - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CONSTANT); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); r_result.insert(option.display, option); } @@ -958,7 +965,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base if (E.name.contains("/")) { continue; } - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); r_result.insert(option.display, option); } } @@ -971,7 +978,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base if (E.name.begins_with("_")) { continue; } - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); if (E.arguments.size()) { option.insert_text += "("; } else { @@ -1001,7 +1008,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base for (const PropertyInfo &E : members) { if (!String(E.name).contains("/")) { - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); r_result.insert(option.display, option); } } @@ -1010,7 +1017,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base List<MethodInfo> methods; tmp.get_method_list(&methods); for (const MethodInfo &E : methods) { - ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); if (E.arguments.size()) { option.insert_text += "("; } else { @@ -1028,7 +1035,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base } } -static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) { +static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) { if (!p_only_functions && p_context.current_suite) { // This includes function parameters, since they are also locals. _find_identifiers_in_suite(p_context.current_suite, r_result); @@ -1043,7 +1050,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool for (const StringName &E : functions) { MethodInfo function = GDScriptUtilityFunctions::get_function_info(E); - ScriptCodeCompletionOption option(String(E), ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(String(E), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); if (function.arguments.size() || (function.flags & METHOD_FLAG_VARARG)) { option.insert_text += "("; } else { @@ -1064,7 +1071,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool static_assert((sizeof(_type_names) / sizeof(*_type_names)) == Variant::VARIANT_MAX, "Completion for builtin types is incomplete"); for (int i = 0; i < Variant::VARIANT_MAX; i++) { - ScriptCodeCompletionOption option(_type_names[i], ScriptCodeCompletionOption::KIND_CLASS); + ScriptLanguage::CodeCompletionOption option(_type_names[i], ScriptLanguage::CODE_COMPLETION_KIND_CLASS); r_result.insert(option.display, option); } @@ -1076,7 +1083,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool const char **kw = _keywords; while (*kw) { - ScriptCodeCompletionOption option(*kw, ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(*kw, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_result.insert(option.display, option); kw++; } @@ -1089,7 +1096,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool const char **kws = _keywords_with_space; while (*kws) { - ScriptCodeCompletionOption option(*kws, ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(*kws, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); option.insert_text += " "; r_result.insert(option.display, option); kws++; @@ -1102,7 +1109,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool const char **kwa = _keywords_with_args; while (*kwa) { - ScriptCodeCompletionOption option(*kwa, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(*kwa, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); option.insert_text += "("; r_result.insert(option.display, option); kwa++; @@ -1112,7 +1119,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool Variant::get_utility_function_list(&utility_func_names); for (List<StringName>::Element *E = utility_func_names.front(); E; E = E->next()) { - ScriptCodeCompletionOption option(E->get(), ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(E->get(), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); option.insert_text += "("; r_result.insert(option.display, option); } @@ -1122,17 +1129,17 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool if (!E.value().is_singleton) { continue; } - ScriptCodeCompletionOption option(E.key(), ScriptCodeCompletionOption::KIND_CONSTANT); + ScriptLanguage::CodeCompletionOption option(E.key(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); r_result.insert(option.display, option); } // Native classes and global constants. for (const KeyValue<StringName, int> &E : GDScriptLanguage::get_singleton()->get_global_map()) { - ScriptCodeCompletionOption option; + ScriptLanguage::CodeCompletionOption option; if (ClassDB::class_exists(E.key) || Engine::get_singleton()->has_singleton(E.key)) { - option = ScriptCodeCompletionOption(E.key.operator String(), ScriptCodeCompletionOption::KIND_CLASS); + option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CLASS); } else { - option = ScriptCodeCompletionOption(E.key.operator String(), ScriptCodeCompletionOption::KIND_CONSTANT); + option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); } r_result.insert(option.display, option); } @@ -2210,20 +2217,20 @@ static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContex return false; } -static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, Map<String, ScriptCodeCompletionOption> &r_result) { +static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) { if (!p_enum_hint.contains(".")) { // Global constant or in the current class. StringName current_enum = p_enum_hint; if (p_context.current_class && p_context.current_class->has_member(current_enum) && p_context.current_class->get_member(current_enum).type == GDScriptParser::ClassNode::Member::ENUM) { const GDScriptParser::EnumNode *_enum = p_context.current_class->get_member(current_enum).m_enum; for (int i = 0; i < _enum->values.size(); i++) { - ScriptCodeCompletionOption option(_enum->values[i].identifier->name, ScriptCodeCompletionOption::KIND_ENUM); + ScriptLanguage::CodeCompletionOption option(_enum->values[i].identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM); r_result.insert(option.display, option); } } else { for (int i = 0; i < CoreConstants::get_global_constant_count(); i++) { if (CoreConstants::get_global_constant_enum(i) == current_enum) { - ScriptCodeCompletionOption option(CoreConstants::get_global_constant_name(i), ScriptCodeCompletionOption::KIND_ENUM); + ScriptLanguage::CodeCompletionOption option(CoreConstants::get_global_constant_name(i), ScriptLanguage::CODE_COMPLETION_KIND_ENUM); r_result.insert(option.display, option); } } @@ -2240,13 +2247,13 @@ static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_co ClassDB::get_enum_constants(class_name, enum_name, &enum_constants); for (const StringName &E : enum_constants) { String candidate = class_name + "." + E; - ScriptCodeCompletionOption option(candidate, ScriptCodeCompletionOption::KIND_ENUM); + ScriptLanguage::CodeCompletionOption option(candidate, ScriptLanguage::CODE_COMPLETION_KIND_ENUM); r_result.insert(option.display, option); } } } -static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptCodeCompletionOption> &r_result, String &r_arghint) { +static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) { Variant base = p_base.value; GDScriptParser::DataType base_type = p_base.type; @@ -2287,7 +2294,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c if (opt.is_quoted()) { opt = opt.unquote().quote(quote_style); // Handle user preference. } - ScriptCodeCompletionOption option(opt, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); r_result.insert(option.display, option); } } @@ -2314,7 +2321,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c continue; } String name = s.get_slice("/", 1); - ScriptCodeCompletionOption option("/root/" + name, ScriptCodeCompletionOption::KIND_NODE_PATH); + ScriptLanguage::CodeCompletionOption option("/root/" + name, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH); option.insert_text = option.display.quote(quote_style); r_result.insert(option.display, option); } @@ -2330,7 +2337,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c continue; } String name = s.get_slice("/", 1); - ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_CONSTANT); + ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); option.insert_text = option.display.quote(quote_style); r_result.insert(option.display, option); } @@ -2365,7 +2372,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c } } -static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, Map<String, ScriptCodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) { +static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) { if (p_call->type == GDScriptParser::Node::PRELOAD) { if (p_argidx == 0 && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) { _get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result); @@ -2444,7 +2451,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c r_forced = r_result.size() > 0; } -::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) { +::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) { const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\""; GDScriptParser parser; @@ -2454,7 +2461,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c analyzer.analyze(); r_forced = false; - Map<String, ScriptCodeCompletionOption> options; + Map<String, ScriptLanguage::CodeCompletionOption> options; GDScriptParser::CompletionContext completion_context = parser.get_completion_context(); completion_context.base = p_owner; @@ -2467,7 +2474,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c List<MethodInfo> annotations; parser.get_annotation_list(&annotations); for (const MethodInfo &E : annotations) { - ScriptCodeCompletionOption option(E.name.substr(1), ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(E.name.substr(1), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); if (E.arguments.size() > 0) { option.insert_text += "("; } @@ -2487,7 +2494,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c List<StringName> constants; Variant::get_constants_for_type(completion_context.builtin_type, &constants); for (const StringName &E : constants) { - ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CONSTANT); + ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); bool valid = false; Variant default_value = Variant::get_constant_value(completion_context.builtin_type, E, &valid); if (valid) { @@ -2501,7 +2508,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c r_forced = true; } break; case GDScriptParser::COMPLETION_TYPE_NAME_OR_VOID: { - ScriptCodeCompletionOption option("void", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option("void", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); options.insert(option.display, option); } [[fallthrough]]; @@ -2511,16 +2518,16 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c } break; case GDScriptParser::COMPLETION_PROPERTY_DECLARATION_OR_TYPE: { _list_available_types(false, completion_context, options); - ScriptCodeCompletionOption get("get", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); options.insert(get.display, get); - ScriptCodeCompletionOption set("set", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); options.insert(set.display, set); r_forced = true; } break; case GDScriptParser::COMPLETION_PROPERTY_DECLARATION: { - ScriptCodeCompletionOption get("get", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); options.insert(get.display, get); - ScriptCodeCompletionOption set("set", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); options.insert(set.display, set); r_forced = true; } break; @@ -2536,7 +2543,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c if (member.function->is_static) { continue; } - ScriptCodeCompletionOption option(member.function->identifier->name, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); options.insert(option.display, option); } r_forced = true; @@ -2706,7 +2713,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c } method_hint += ":"; - ScriptCodeCompletionOption option(method_hint, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(method_hint, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); options.insert(option.display, option); } } break; @@ -2729,7 +2736,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c if (!opt.replace("/", "_").is_valid_identifier()) { opt = opt.quote(quote_style); // Handle user preference. } - ScriptCodeCompletionOption option(opt, ScriptCodeCompletionOption::KIND_NODE_PATH); + ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH); options.insert(option.display, option); } @@ -2738,7 +2745,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c for (OrderedHashMap<StringName, ProjectSettings::AutoloadInfo>::Element E = autoloads.front(); E; E = E.next()) { String path = "/root/" + E.key(); - ScriptCodeCompletionOption option(path.quote(quote_style), ScriptCodeCompletionOption::KIND_NODE_PATH); + ScriptLanguage::CodeCompletionOption option(path.quote(quote_style), ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH); options.insert(option.display, option); } } @@ -2751,7 +2758,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c } break; } - for (const KeyValue<String, ScriptCodeCompletionOption> &E : options) { + for (const KeyValue<String, ScriptLanguage::CodeCompletionOption> &E : options) { r_options->push_back(E.value); } @@ -2760,7 +2767,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c #else -Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) { +Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) { return OK; } @@ -2859,7 +2866,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co case GDScriptParser::DataType::CLASS: { if (base_type.class_type) { if (base_type.class_type->has_member(p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION; r_result.location = base_type.class_type->get_member(p_symbol).get_line(); r_result.class_path = base_type.script_path; r_result.script = GDScriptCache::get_shallow_script(r_result.class_path); @@ -2873,7 +2880,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co if (scr.is_valid()) { int line = scr->get_member_line(p_symbol); if (line >= 0) { - r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION; r_result.location = line; r_result.script = scr; return OK; @@ -2897,7 +2904,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co } if (ClassDB::has_method(class_name, p_symbol, true)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD; r_result.class_name = base_type.native_type; r_result.class_member = p_symbol; return OK; @@ -2907,7 +2914,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co ClassDB::get_virtual_methods(class_name, &virtual_methods, true); for (const MethodInfo &E : virtual_methods) { if (E.name == p_symbol) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD; r_result.class_name = base_type.native_type; r_result.class_member = p_symbol; return OK; @@ -2916,7 +2923,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co StringName enum_name = ClassDB::get_integer_constant_enum(class_name, p_symbol, true); if (enum_name != StringName()) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_ENUM; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM; r_result.class_name = base_type.native_type; r_result.class_member = enum_name; return OK; @@ -2926,7 +2933,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co ClassDB::get_integer_constant_list(class_name, &constants, true); for (const String &E : constants) { if (E == p_symbol) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = base_type.native_type; r_result.class_member = p_symbol; return OK; @@ -2934,7 +2941,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co } if (ClassDB::has_property(class_name, p_symbol, true)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY; r_result.class_name = base_type.native_type; r_result.class_member = p_symbol; return OK; @@ -2951,7 +2958,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co base_type.kind = GDScriptParser::DataType::UNRESOLVED; if (Variant::has_constant(base_type.builtin_type, p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = Variant::get_type_name(base_type.builtin_type); r_result.class_member = p_symbol; return OK; @@ -2971,7 +2978,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co } if (v.has_method(p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD; r_result.class_name = Variant::get_type_name(base_type.builtin_type); r_result.class_member = p_symbol; return OK; @@ -2980,7 +2987,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co bool valid = false; v.get(p_symbol, &valid); if (valid) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY; r_result.class_name = Variant::get_type_name(base_type.builtin_type); r_result.class_member = p_symbol; return OK; @@ -2998,7 +3005,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co ::Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) { // Before parsing, try the usual stuff if (ClassDB::class_exists(p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS; r_result.class_name = p_symbol; return OK; } @@ -3006,21 +3013,21 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co for (int i = 0; i < Variant::VARIANT_MAX; i++) { Variant::Type t = Variant::Type(i); if (Variant::get_type_name(t) == p_symbol) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS; r_result.class_name = Variant::get_type_name(t); return OK; } } if (GDScriptUtilityFunctions::function_exists(p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD; r_result.class_name = "@GDScript"; r_result.class_member = p_symbol; return OK; } if ("PI" == p_symbol || "TAU" == p_symbol || "INF" == p_symbol || "NAN" == p_symbol) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = "@GDScript"; r_result.class_member = p_symbol; return OK; @@ -3037,7 +3044,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co bool success = false; ClassDB::get_integer_constant(context.current_class->extends[0], p_symbol, &success); if (success) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = context.current_class->extends[0]; r_result.class_member = p_symbol; return OK; @@ -3048,7 +3055,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co switch (context.type) { case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = Variant::get_type_name(context.builtin_type); r_result.class_member = p_symbol; return OK; @@ -3076,7 +3083,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co const GDScriptParser::SuiteNode *suite = context.current_suite; while (suite) { if (suite->has_local(p_symbol)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION; r_result.location = suite->get_local(p_symbol).start_line; return OK; } @@ -3101,7 +3108,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co } if (FileAccess::exists(script)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION; r_result.location = 0; r_result.script = ResourceLoader::load(script); return OK; @@ -3117,10 +3124,10 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co Object *obj = value; if (obj) { if (Object::cast_to<GDScriptNativeClass>(obj)) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS; r_result.class_name = Object::cast_to<GDScriptNativeClass>(obj)->get_name(); } else { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS; r_result.class_name = obj->get_class(); } @@ -3137,18 +3144,18 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co // Otherwise these codes would work StringName enumName = ClassDB::get_integer_constant_enum("@GlobalScope", p_symbol, true); if (enumName != nullptr) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_ENUM; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM; r_result.class_name = "@GlobalScope"; r_result.class_member = enumName; return OK; } else { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT; r_result.class_name = "@GlobalScope"; r_result.class_member = p_symbol; return OK; }*/ - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE; r_result.class_name = "@GlobalScope"; r_result.class_member = p_symbol; return OK; @@ -3157,7 +3164,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co List<StringName> utility_functions; Variant::get_utility_function_list(&utility_functions); if (utility_functions.find(p_symbol) != nullptr) { - r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE; + r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE; r_result.class_name = "@GlobalScope"; r_result.class_member = p_symbol; return OK; diff --git a/modules/gdscript/language_server/gdscript_text_document.cpp b/modules/gdscript/language_server/gdscript_text_document.cpp index 961295b076..d5ef8fed74 100644 --- a/modules/gdscript/language_server/gdscript_text_document.cpp +++ b/modules/gdscript/language_server/gdscript_text_document.cpp @@ -166,49 +166,51 @@ Array GDScriptTextDocument::completion(const Dictionary &p_params) { params.load(p_params); Dictionary request_data = params.to_json(); - List<ScriptCodeCompletionOption> options; + List<ScriptLanguage::CodeCompletionOption> options; GDScriptLanguageProtocol::get_singleton()->get_workspace()->completion(params, &options); if (!options.is_empty()) { int i = 0; arr.resize(options.size()); - for (const ScriptCodeCompletionOption &option : options) { + for (const ScriptLanguage::CodeCompletionOption &option : options) { lsp::CompletionItem item; item.label = option.display; item.data = request_data; switch (option.kind) { - case ScriptCodeCompletionOption::KIND_ENUM: + case ScriptLanguage::CODE_COMPLETION_KIND_ENUM: item.kind = lsp::CompletionItemKind::Enum; break; - case ScriptCodeCompletionOption::KIND_CLASS: + case ScriptLanguage::CODE_COMPLETION_KIND_CLASS: item.kind = lsp::CompletionItemKind::Class; break; - case ScriptCodeCompletionOption::KIND_MEMBER: + case ScriptLanguage::CODE_COMPLETION_KIND_MEMBER: item.kind = lsp::CompletionItemKind::Property; break; - case ScriptCodeCompletionOption::KIND_FUNCTION: + case ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION: item.kind = lsp::CompletionItemKind::Method; break; - case ScriptCodeCompletionOption::KIND_SIGNAL: + case ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL: item.kind = lsp::CompletionItemKind::Event; break; - case ScriptCodeCompletionOption::KIND_CONSTANT: + case ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT: item.kind = lsp::CompletionItemKind::Constant; break; - case ScriptCodeCompletionOption::KIND_VARIABLE: + case ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE: item.kind = lsp::CompletionItemKind::Variable; break; - case ScriptCodeCompletionOption::KIND_FILE_PATH: + case ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH: item.kind = lsp::CompletionItemKind::File; break; - case ScriptCodeCompletionOption::KIND_NODE_PATH: + case ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH: item.kind = lsp::CompletionItemKind::Snippet; break; - case ScriptCodeCompletionOption::KIND_PLAIN_TEXT: + case ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT: item.kind = lsp::CompletionItemKind::Text; break; + default: { + } } arr[i] = item.to_json(); diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp index d20b243616..1bf0b40842 100644 --- a/modules/gdscript/language_server/gdscript_workspace.cpp +++ b/modules/gdscript/language_server/gdscript_workspace.cpp @@ -571,7 +571,7 @@ Node *GDScriptWorkspace::_get_owner_scene_node(String p_path) { return owner_scene_node; } -void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options) { +void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<ScriptLanguage::CodeCompletionOption> *r_options) { String path = get_file_path(p_params.textDocument.uri); String call_hint; bool forced = false; @@ -638,7 +638,7 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu symbol_identifier = "_init"; } if (OK == GDScriptLanguage::get_singleton()->lookup_code(parser->get_text_for_lookup_symbol(pos, symbol_identifier, p_func_required), symbol_identifier, path, nullptr, ret)) { - if (ret.type == ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION) { + if (ret.type == ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION) { String target_script_path = path; if (!ret.script.is_null()) { target_script_path = ret.script->get_path(); diff --git a/modules/gdscript/language_server/gdscript_workspace.h b/modules/gdscript/language_server/gdscript_workspace.h index ce5bba5f00..92e78f8992 100644 --- a/modules/gdscript/language_server/gdscript_workspace.h +++ b/modules/gdscript/language_server/gdscript_workspace.h @@ -85,7 +85,7 @@ public: String get_file_uri(const String &p_path) const; void publish_diagnostics(const String &p_path); - void completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options); + void completion(const lsp::CompletionParams &p_params, List<ScriptLanguage::CodeCompletionOption> *r_options); const lsp::DocumentSymbol *resolve_symbol(const lsp::TextDocumentPositionParams &p_doc_pos, const String &p_symbol_name = "", bool p_func_required = false); void resolve_related_symbols(const lsp::TextDocumentPositionParams &p_doc_pos, List<const lsp::DocumentSymbol *> &r_list); diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h index 3b97d2acc4..1e5f218c95 100644 --- a/modules/mono/csharp_script.h +++ b/modules/mono/csharp_script.h @@ -202,9 +202,9 @@ public: void set_source_code(const String &p_code) override; #ifdef TOOLS_ENABLED - virtual const Vector<DocData::ClassDoc> &get_documentation() const override { + virtual Vector<DocData::ClassDoc> get_documentation() const override { // TODO - static Vector<DocData::ClassDoc> docs; + Vector<DocData::ClassDoc> docs; return docs; } #endif // TOOLS_ENABLED diff --git a/modules/mono/editor_templates/EditorPlugin/plugin.cs b/modules/mono/editor_templates/EditorPlugin/plugin.cs index 6e6a799be6..eba5fd12a4 100644 --- a/modules/mono/editor_templates/EditorPlugin/plugin.cs +++ b/modules/mono/editor_templates/EditorPlugin/plugin.cs @@ -1,4 +1,5 @@ // meta-description: Basic plugin template + #if TOOLS using _BINDINGS_NAMESPACE_; using System; diff --git a/modules/mono/editor_templates/EditorScript/basic_editor_script.cs b/modules/mono/editor_templates/EditorScript/basic_editor_script.cs index 2088822890..1b347edc1c 100644 --- a/modules/mono/editor_templates/EditorScript/basic_editor_script.cs +++ b/modules/mono/editor_templates/EditorScript/basic_editor_script.cs @@ -1,4 +1,5 @@ // meta-description: Basic editor script template + #if TOOLS using _BINDINGS_NAMESPACE_; using System; @@ -6,9 +7,9 @@ using System; [Tool] public partial class _CLASS_ : _BASE_ { + // Called when the script is executed (using File -> Run in Script Editor). public override void _Run() { - // Called when the script is executed (using File -> Run in Script Editor). } } #endif diff --git a/modules/mono/editor_templates/Node/default.cs b/modules/mono/editor_templates/Node/default.cs index 73d69dd993..4c86d1666f 100644 --- a/modules/mono/editor_templates/Node/default.cs +++ b/modules/mono/editor_templates/Node/default.cs @@ -8,12 +8,10 @@ public partial class _CLASS_ : _BASE_ // Called when the node enters the scene tree for the first time. public override void _Ready() { - } // Called every frame. 'delta' is the elapsed time since the previous frame. public override void _Process(float delta) { - } } diff --git a/modules/mono/editor_templates/Object/empty.cs b/modules/mono/editor_templates/Object/empty.cs index e5bee64fe1..34526d514f 100644 --- a/modules/mono/editor_templates/Object/empty.cs +++ b/modules/mono/editor_templates/Object/empty.cs @@ -5,5 +5,4 @@ using System; public partial class _CLASS_ : _BASE_ { - } diff --git a/modules/text_server_adv/SCsub b/modules/text_server_adv/SCsub index e999700d55..dfd3bb3f1e 100644 --- a/modules/text_server_adv/SCsub +++ b/modules/text_server_adv/SCsub @@ -37,7 +37,7 @@ def make_icu_data(target, source, env): thirdparty_obj = [] freetype_enabled = env.module_check_dependencies("text_server_adv", ["freetype"], True) -msdngen_enabled = env.module_check_dependencies("text_server_adv", ["msdfgen"], True) +msdfgen_enabled = env.module_check_dependencies("text_server_adv", ["msdfgen"], True) if env["builtin_harfbuzz"]: env_harfbuzz = env_modules.Clone() @@ -117,20 +117,25 @@ if env["builtin_harfbuzz"]: ] thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources] - env_harfbuzz.Append( - CPPPATH=[ - "#thirdparty/harfbuzz/src", - "#thirdparty/icu4c/common/", - ] - ) + env_harfbuzz.Append(CPPPATH=["#thirdparty/harfbuzz/src"]) + + env_harfbuzz.Append(CCFLAGS=["-DHAVE_ICU"]) + if env["builtin_icu"]: + env_harfbuzz.Append(CPPPATH=["#thirdparty/icu4c/common/"]) + env_harfbuzz.Append(CCFLAGS=["-DHAVE_ICU_BUILTIN"]) if freetype_enabled: env_harfbuzz.Append( - CPPPATH=[ - "#thirdparty/freetype/include", - "#thirdparty/graphite/include", + CCFLAGS=[ + "-DHAVE_FREETYPE", + "-DHAVE_GRAPHITE2", ] ) + if env["builtin_freetype"]: + env_harfbuzz.Append(CPPPATH=["#thirdparty/freetype/include"]) + if env["builtin_graphite"]: + env_harfbuzz.Append(CPPPATH=["#thirdparty/graphite/include"]) + env_harfbuzz.Append(CCFLAGS=["-DGRAPHITE2_STATIC"]) if env["platform"] == "android" or env["platform"] == "linuxbsd": env_harfbuzz.Append(CCFLAGS=["-DHAVE_PTHREAD"]) @@ -141,21 +146,7 @@ if env["builtin_harfbuzz"]: else: env_harfbuzz.Append(CCFLAGS=["-DHB_NO_MT"]) - env_harfbuzz.Append( - CCFLAGS=[ - "-DHAVE_ICU_BUILTIN", - "-DHAVE_ICU", - ] - ) - - if freetype_enabled: - env_harfbuzz.Append( - CCFLAGS=[ - "-DHAVE_FREETYPE", - "-DHAVE_GRAPHITE2", - "-DGRAPHITE2_STATIC", - ] - ) + env_text_server_adv.Append(CPPPATH=["#thirdparty/harfbuzz/src"]) lib = env_harfbuzz.add_library("harfbuzz_builtin", thirdparty_sources) thirdparty_obj += lib @@ -481,6 +472,10 @@ if env["builtin_icu"]: "-DICU_DATA_NAME=" + icu_data_name, ] ) + if env_text_server_adv["tools"]: + env_text_server_adv.Append(CXXFLAGS=["-DICU_STATIC_DATA"]) + + env_text_server_adv.Append(CPPPATH=["#thirdparty/icu4c/common/"]) lib = env_icu.add_library("icu_builtin", thirdparty_sources) thirdparty_obj += lib @@ -503,30 +498,14 @@ if env["builtin_icu"]: module_obj = [] -if env_text_server_adv["tools"]: - env_text_server_adv.Append(CXXFLAGS=["-DICU_STATIC_DATA"]) +if env["builtin_msdfgen"] and msdfgen_enabled: + env_text_server_adv.Append(CPPPATH=["#thirdparty/msdfgen"]) -env_text_server_adv.Append( - CPPPATH=[ - "#thirdparty/harfbuzz/src", - "#thirdparty/icu4c/common/", - ] -) +if env["builtin_freetype"] and freetype_enabled: + env_text_server_adv.Append(CPPPATH=["#thirdparty/freetype/include"]) -if msdngen_enabled: - env_text_server_adv.Append( - CPPPATH=[ - "#thirdparty/msdfgen", - ] - ) - -if freetype_enabled: - env_text_server_adv.Append( - CPPPATH=[ - "#thirdparty/freetype/include", - "#thirdparty/graphite/include", - ] - ) +if env["builtin_graphite"] and freetype_enabled: + env_text_server_adv.Append(CPPPATH=["#thirdparty/graphite/include"]) env_text_server_adv.add_source_files(module_obj, "*.cpp") env.modules_sources += module_obj diff --git a/modules/text_server_fb/SCsub b/modules/text_server_fb/SCsub index 31d1db6167..121f38fcd5 100644 --- a/modules/text_server_fb/SCsub +++ b/modules/text_server_fb/SCsub @@ -4,22 +4,14 @@ Import("env") Import("env_modules") freetype_enabled = env.module_check_dependencies("text_server_fb", ["freetype"], True) -msdngen_enabled = env.module_check_dependencies("text_server_fb", ["msdfgen"], True) +msdfgen_enabled = env.module_check_dependencies("text_server_fb", ["msdfgen"], True) env_text_server_fb = env_modules.Clone() -if msdngen_enabled: - env_text_server_fb.Append( - CPPPATH=[ - "#thirdparty/msdfgen", - ] - ) +if env["builtin_msdfgen"] and msdfgen_enabled: + env_text_server_fb.Append(CPPPATH=["#thirdparty/msdfgen"]) -if freetype_enabled: - env_text_server_fb.Append( - CPPPATH=[ - "#thirdparty/freetype/include", - ] - ) +if env["builtin_freetype"] and freetype_enabled: + env_text_server_fb.Append(CPPPATH=["#thirdparty/freetype/include"]) env_text_server_fb.add_source_files(env.modules_sources, "*.cpp") diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h index d4dffdfc7a..d72bdf9128 100644 --- a/modules/visual_script/visual_script.h +++ b/modules/visual_script/visual_script.h @@ -338,8 +338,8 @@ public: virtual Error reload(bool p_keep_state = false) override; #ifdef TOOLS_ENABLED - virtual const Vector<DocData::ClassDoc> &get_documentation() const override { - static Vector<DocData::ClassDoc> docs; + virtual Vector<DocData::ClassDoc> get_documentation() const override { + Vector<DocData::ClassDoc> docs; return docs; } #endif // TOOLS_ENABLED diff --git a/platform/javascript/export/export_plugin.cpp b/platform/javascript/export/export_plugin.cpp index 4448acccc2..84694461cf 100644 --- a/platform/javascript/export/export_plugin.cpp +++ b/platform/javascript/export/export_plugin.cpp @@ -360,6 +360,15 @@ Ref<Texture2D> EditorExportPlatformJavaScript::get_logo() const { } bool EditorExportPlatformJavaScript::can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const { +#ifndef DEV_ENABLED + // We don't provide export templates for the HTML5 platform currently as there + // is no suitable renderer to use with them. So we forbid exporting and tell + // users why. This is skipped in DEV_ENABLED so that contributors can still test + // the pipeline once we start having WebGL or WebGPU support. + r_error = "The HTML5 platform is currently not supported in Godot 4.0, as there is no suitable renderer for it.\n"; + return false; +#endif + String err; bool valid = false; ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type"); diff --git a/platform/linuxbsd/display_server_x11.cpp b/platform/linuxbsd/display_server_x11.cpp index 07cb6a23e8..2ddccdb8bf 100644 --- a/platform/linuxbsd/display_server_x11.cpp +++ b/platform/linuxbsd/display_server_x11.cpp @@ -363,15 +363,15 @@ DisplayServerX11::MouseMode DisplayServerX11::mouse_get_mode() const { return mouse_mode; } -void DisplayServerX11::mouse_warp_to_position(const Point2i &p_to) { +void DisplayServerX11::warp_mouse(const Point2i &p_position) { _THREAD_SAFE_METHOD_ if (mouse_mode == MOUSE_MODE_CAPTURED) { - last_mouse_pos = p_to; + last_mouse_pos = p_position; } else { WindowID window_id = windows.has(last_focused_window) ? last_focused_window : MAIN_WINDOW_ID; XWarpPointer(x11_display, None, windows[window_id].x11_window, - 0, 0, 0, 0, (int)p_to.x, (int)p_to.y); + 0, 0, 0, 0, (int)p_position.x, (int)p_position.y); } } diff --git a/platform/linuxbsd/display_server_x11.h b/platform/linuxbsd/display_server_x11.h index 63d32d939d..0f44aa4b11 100644 --- a/platform/linuxbsd/display_server_x11.h +++ b/platform/linuxbsd/display_server_x11.h @@ -301,7 +301,7 @@ public: virtual void mouse_set_mode(MouseMode p_mode) override; virtual MouseMode mouse_get_mode() const override; - virtual void mouse_warp_to_position(const Point2i &p_to) override; + virtual void warp_mouse(const Point2i &p_position) override; virtual Point2i mouse_get_position() const override; virtual MouseButton mouse_get_button_state() const override; diff --git a/platform/osx/display_server_osx.h b/platform/osx/display_server_osx.h index d9a0d2ce17..fa3091ff81 100644 --- a/platform/osx/display_server_osx.h +++ b/platform/osx/display_server_osx.h @@ -271,7 +271,7 @@ public: virtual MouseMode mouse_get_mode() const override; bool update_mouse_wrap(WindowData &p_wd, NSPoint &r_delta, NSPoint &r_mpos, NSTimeInterval p_timestamp); - virtual void mouse_warp_to_position(const Point2i &p_to) override; + virtual void warp_mouse(const Point2i &p_position) override; virtual Point2i mouse_get_position() const override; void mouse_set_button_state(MouseButton p_state); virtual MouseButton mouse_get_button_state() const override; diff --git a/platform/osx/display_server_osx.mm b/platform/osx/display_server_osx.mm index 8820201c10..6cdadcae39 100644 --- a/platform/osx/display_server_osx.mm +++ b/platform/osx/display_server_osx.mm @@ -1646,7 +1646,7 @@ bool DisplayServerOSX::update_mouse_wrap(WindowData &p_wd, NSPoint &r_delta, NSP return false; } -void DisplayServerOSX::mouse_warp_to_position(const Point2i &p_to) { +void DisplayServerOSX::warp_mouse(const Point2i &p_position) { _THREAD_SAFE_METHOD_ if (mouse_mode != MOUSE_MODE_CAPTURED) { @@ -1656,7 +1656,7 @@ void DisplayServerOSX::mouse_warp_to_position(const Point2i &p_to) { // Local point in window coords. const NSRect contentRect = [wd.window_view frame]; const float scale = screen_get_max_scale(); - NSRect pointInWindowRect = NSMakeRect(p_to.x / scale, contentRect.size.height - (p_to.y / scale - 1), 0, 0); + NSRect pointInWindowRect = NSMakeRect(p_position.x / scale, contentRect.size.height - (p_position.y / scale - 1), 0, 0); NSPoint pointOnScreen = [[wd.window_view window] convertRectToScreen:pointInWindowRect].origin; // Point in scren coords. diff --git a/platform/uwp/export/export_plugin.cpp b/platform/uwp/export/export_plugin.cpp index 230e5c749c..88343d6f85 100644 --- a/platform/uwp/export/export_plugin.cpp +++ b/platform/uwp/export/export_plugin.cpp @@ -131,6 +131,14 @@ void EditorExportPlatformUWP::get_export_options(List<ExportOption> *r_options) } bool EditorExportPlatformUWP::can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const { +#ifndef DEV_ENABLED + // We don't provide export templates for the UWP platform currently as it + // has not been ported for Godot 4.0. This is skipped in DEV_ENABLED so that + // contributors can still test the pipeline if/when we can build it again. + r_error = "The UWP platform is currently not supported in Godot 4.0.\n"; + return false; +#endif + String err; bool valid = false; diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp index d243d4c05d..16323dcc13 100644 --- a/platform/windows/display_server_windows.cpp +++ b/platform/windows/display_server_windows.cpp @@ -150,7 +150,7 @@ DisplayServer::MouseMode DisplayServerWindows::mouse_get_mode() const { return mouse_mode; } -void DisplayServerWindows::mouse_warp_to_position(const Point2i &p_to) { +void DisplayServerWindows::warp_mouse(const Point2i &p_position) { _THREAD_SAFE_METHOD_ if (!windows.has(last_focused_window)) { @@ -158,12 +158,12 @@ void DisplayServerWindows::mouse_warp_to_position(const Point2i &p_to) { } if (mouse_mode == MOUSE_MODE_CAPTURED) { - old_x = p_to.x; - old_y = p_to.y; + old_x = p_position.x; + old_y = p_position.y; } else { POINT p; - p.x = p_to.x; - p.y = p_to.y; + p.x = p_position.x; + p.y = p_position.y; ClientToScreen(windows[last_focused_window].hWnd, &p); SetCursorPos(p.x, p.y); diff --git a/platform/windows/display_server_windows.h b/platform/windows/display_server_windows.h index a56a2b83ac..71fedf2bca 100644 --- a/platform/windows/display_server_windows.h +++ b/platform/windows/display_server_windows.h @@ -457,7 +457,7 @@ public: virtual void mouse_set_mode(MouseMode p_mode) override; virtual MouseMode mouse_get_mode() const override; - virtual void mouse_warp_to_position(const Point2i &p_to) override; + virtual void warp_mouse(const Point2i &p_position) override; virtual Point2i mouse_get_position() const override; virtual MouseButton mouse_get_button_state() const override; diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp index a2fed718be..c8eb270a0a 100644 --- a/scene/animation/tween.cpp +++ b/scene/animation/tween.cpp @@ -741,12 +741,12 @@ bool PropertyTweener::step(float &r_delta) { } float time = MIN(elapsed_time - delay, duration); - target_instance->set_indexed(property, tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type)); - if (time < duration) { + target_instance->set_indexed(property, tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type)); r_delta = 0; return true; } else { + target_instance->set_indexed(property, final_val); finished = true; r_delta = elapsed_time - delay - duration; emit_signal(SNAME("finished")); @@ -895,8 +895,13 @@ bool MethodTweener::step(float &r_delta) { return true; } + Variant current_val; float time = MIN(elapsed_time - delay, duration); - Variant current_val = tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type); + if (time < duration) { + current_val = tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type); + } else { + current_val = final_val; + } const Variant **argptr = (const Variant **)alloca(sizeof(Variant *)); argptr[0] = ¤t_val; @@ -938,6 +943,7 @@ MethodTweener::MethodTweener(Callable p_callback, Variant p_from, Variant p_to, callback = p_callback; initial_val = p_from; delta_val = tween->calculate_delta_value(p_from, p_to); + final_val = p_to; duration = p_duration; } diff --git a/scene/animation/tween.h b/scene/animation/tween.h index 5b0745b2b3..62c357dfb4 100644 --- a/scene/animation/tween.h +++ b/scene/animation/tween.h @@ -274,6 +274,7 @@ private: Ref<Tween> tween; Variant initial_val; Variant delta_val; + Variant final_val; Callable callback; }; diff --git a/scene/gui/code_edit.cpp b/scene/gui/code_edit.cpp index 3fa0cec302..e094c4546b 100644 --- a/scene/gui/code_edit.cpp +++ b/scene/gui/code_edit.cpp @@ -1782,10 +1782,10 @@ void CodeEdit::request_code_completion(bool p_force) { /* Don't re-query if all existing options are quoted types, eg path, signal. */ bool ignored = code_completion_active && !code_completion_options.is_empty(); if (ignored) { - ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_PLAIN_TEXT; - const ScriptCodeCompletionOption *previous_option = nullptr; + ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT; + const ScriptLanguage::CodeCompletionOption *previous_option = nullptr; for (int i = 0; i < code_completion_options.size(); i++) { - const ScriptCodeCompletionOption ¤t_option = code_completion_options[i]; + const ScriptLanguage::CodeCompletionOption ¤t_option = code_completion_options[i]; if (!previous_option) { previous_option = ¤t_option; kind = current_option.kind; @@ -1795,7 +1795,7 @@ void CodeEdit::request_code_completion(bool p_force) { break; } } - ignored = ignored && (kind == ScriptCodeCompletionOption::KIND_FILE_PATH || kind == ScriptCodeCompletionOption::KIND_NODE_PATH || kind == ScriptCodeCompletionOption::KIND_SIGNAL); + ignored = ignored && (kind == ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL); } if (ignored) { @@ -1818,8 +1818,8 @@ void CodeEdit::request_code_completion(bool p_force) { } void CodeEdit::add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color, const RES &p_icon, const Variant &p_value) { - ScriptCodeCompletionOption completion_option; - completion_option.kind = (ScriptCodeCompletionOption::Kind)p_type; + ScriptLanguage::CodeCompletionOption completion_option; + completion_option.kind = (ScriptLanguage::CodeCompletionKind)p_type; completion_option.display = p_display_text; completion_option.insert_text = p_insert_text; completion_option.font_color = p_text_color; @@ -2702,7 +2702,7 @@ void CodeEdit::_filter_code_completion_candidates_impl() { TypedArray<Dictionary> completion_options_sources; completion_options_sources.resize(code_completion_option_sources.size()); int i = 0; - for (const ScriptCodeCompletionOption &E : code_completion_option_sources) { + for (const ScriptLanguage::CodeCompletionOption &E : code_completion_option_sources) { Dictionary option; option["kind"] = E.kind; option["display_text"] = E.display; @@ -2727,8 +2727,8 @@ void CodeEdit::_filter_code_completion_candidates_impl() { /* Convert back into options. */ int max_width = 0; for (i = 0; i < completion_options.size(); i++) { - ScriptCodeCompletionOption option; - option.kind = (ScriptCodeCompletionOption::Kind)(int)completion_options[i].get("kind"); + ScriptLanguage::CodeCompletionOption option; + option.kind = (ScriptLanguage::CodeCompletionKind)(int)completion_options[i].get("kind"); option.display = completion_options[i].get("display_text"); option.insert_text = completion_options[i].get("insert_text"); option.font_color = completion_options[i].get("font_color"); @@ -2821,15 +2821,15 @@ void CodeEdit::_filter_code_completion_candidates_impl() { code_completion_options.clear(); code_completion_base = string_to_complete; - Vector<ScriptCodeCompletionOption> completion_options_casei; - Vector<ScriptCodeCompletionOption> completion_options_substr; - Vector<ScriptCodeCompletionOption> completion_options_substr_casei; - Vector<ScriptCodeCompletionOption> completion_options_subseq; - Vector<ScriptCodeCompletionOption> completion_options_subseq_casei; + Vector<ScriptLanguage::CodeCompletionOption> completion_options_casei; + Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr; + Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr_casei; + Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq; + Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq_casei; int max_width = 0; String string_to_complete_lower = string_to_complete.to_lower(); - for (ScriptCodeCompletionOption &option : code_completion_option_sources) { + for (ScriptLanguage::CodeCompletionOption &option : code_completion_option_sources) { if (single_quote && option.display.is_quoted()) { option.display = option.display.unquote().quote("'"); } diff --git a/scene/gui/code_edit.h b/scene/gui/code_edit.h index cb1309ced3..596a065f12 100644 --- a/scene/gui/code_edit.h +++ b/scene/gui/code_edit.h @@ -38,7 +38,7 @@ class CodeEdit : public TextEdit { public: /* Keep enum in sync with: */ - /* /core/object/script_language.h - ScriptCodeCompletionOption::Kind */ + /* /core/object/script_language.h - ScriptLanguage::CodeCompletionKind */ enum CodeCompletionKind { KIND_CLASS, KIND_FUNCTION, @@ -208,15 +208,15 @@ private: Color code_completion_existing_color = Color(0, 0, 0, 0); bool code_completion_active = false; - Vector<ScriptCodeCompletionOption> code_completion_options; + Vector<ScriptLanguage::CodeCompletionOption> code_completion_options; int code_completion_line_ofs = 0; int code_completion_current_selected = 0; int code_completion_longest_line = 0; Rect2i code_completion_rect; Set<char32_t> code_completion_prefixes; - List<ScriptCodeCompletionOption> code_completion_option_submitted; - List<ScriptCodeCompletionOption> code_completion_option_sources; + List<ScriptLanguage::CodeCompletionOption> code_completion_option_submitted; + List<ScriptLanguage::CodeCompletionOption> code_completion_option_sources; String code_completion_base; void _filter_code_completion_candidates_impl(); diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp index d2d1b5e9b7..ee35eee35d 100644 --- a/scene/gui/control.cpp +++ b/scene/gui/control.cpp @@ -2937,9 +2937,9 @@ Control::MouseFilter Control::get_mouse_filter() const { return data.mouse_filter; } -void Control::warp_mouse(const Point2 &p_to_pos) { +void Control::warp_mouse(const Point2 &p_position) { ERR_FAIL_COND(!is_inside_tree()); - get_viewport()->warp_mouse(get_global_transform().xform(p_to_pos)); + get_viewport()->warp_mouse(get_global_transform().xform(p_position)); } bool Control::is_text_field() const { @@ -3331,7 +3331,7 @@ void Control::_bind_methods() { ClassDB::bind_method(D_METHOD("set_drag_preview", "control"), &Control::set_drag_preview); ClassDB::bind_method(D_METHOD("is_drag_successful"), &Control::is_drag_successful); - ClassDB::bind_method(D_METHOD("warp_mouse", "to_position"), &Control::warp_mouse); + ClassDB::bind_method(D_METHOD("warp_mouse", "position"), &Control::warp_mouse); ClassDB::bind_method(D_METHOD("update_minimum_size"), &Control::update_minimum_size); diff --git a/scene/gui/control.h b/scene/gui/control.h index 299cdd673f..4240d52b65 100644 --- a/scene/gui/control.h +++ b/scene/gui/control.h @@ -547,7 +547,7 @@ public: void grab_click_focus(); - void warp_mouse(const Point2 &p_to_pos); + void warp_mouse(const Point2 &p_position); virtual bool is_text_field() const; diff --git a/scene/gui/range.cpp b/scene/gui/range.cpp index 2fb6452a97..2eb41f1631 100644 --- a/scene/gui/range.cpp +++ b/scene/gui/range.cpp @@ -282,7 +282,7 @@ void Range::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::BOOL, "allow_greater"), "set_allow_greater", "is_greater_allowed"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "allow_lesser"), "set_allow_lesser", "is_lesser_allowed"); - GDVIRTUAL_BIND(_value_changed); + GDVIRTUAL_BIND(_value_changed, "new_value"); ADD_LINKED_PROPERTY("min_value", "value"); ADD_LINKED_PROPERTY("min_value", "max_value"); diff --git a/scene/gui/subviewport_container.cpp b/scene/gui/subviewport_container.cpp index c66e145bc4..799eea7eac 100644 --- a/scene/gui/subviewport_container.cpp +++ b/scene/gui/subviewport_container.cpp @@ -223,6 +223,23 @@ void SubViewportContainer::unhandled_input(const Ref<InputEvent> &p_event) { } } +TypedArray<String> SubViewportContainer::get_configuration_warnings() const { + TypedArray<String> warnings = Node::get_configuration_warnings(); + + bool has_viewport = false; + for (int i = 0; i < get_child_count(); i++) { + if (Object::cast_to<SubViewport>(get_child(i))) { + has_viewport = true; + break; + } + } + if (!has_viewport) { + warnings.push_back(TTR("This node doesn't have a SubViewport as child, so it can't display its intended content.\nConsider adding a SubViewport as a child to provide something displayable.")); + } + + return warnings; +} + void SubViewportContainer::_bind_methods() { ClassDB::bind_method(D_METHOD("set_stretch", "enable"), &SubViewportContainer::set_stretch); ClassDB::bind_method(D_METHOD("is_stretch_enabled"), &SubViewportContainer::is_stretch_enabled); diff --git a/scene/gui/subviewport_container.h b/scene/gui/subviewport_container.h index f52f01e4e2..55b7802aa4 100644 --- a/scene/gui/subviewport_container.h +++ b/scene/gui/subviewport_container.h @@ -58,6 +58,8 @@ public: virtual Vector<int> get_allowed_size_flags_horizontal() const override; virtual Vector<int> get_allowed_size_flags_vertical() const override; + TypedArray<String> get_configuration_warnings() const override; + SubViewportContainer(); }; diff --git a/scene/gui/tab_bar.cpp b/scene/gui/tab_bar.cpp index 8128bbd11d..ce2dca0ea3 100644 --- a/scene/gui/tab_bar.cpp +++ b/scene/gui/tab_bar.cpp @@ -35,6 +35,7 @@ #include "scene/gui/box_container.h" #include "scene/gui/label.h" #include "scene/gui/texture_rect.h" +#include "scene/main/viewport.h" Size2 TabBar::get_minimum_size() const { Size2 ms; @@ -158,7 +159,13 @@ void TabBar::gui_input(const Ref<InputEvent> &p_event) { } } + if (get_viewport()->gui_is_dragging() && can_drop_data(pos, get_viewport()->gui_get_drag_data())) { + dragging_valid_tab = true; + update(); + } + _update_hover(); + return; } @@ -333,6 +340,13 @@ void TabBar::_notification(int p_what) { } } break; + case NOTIFICATION_DRAG_END: { + if (dragging_valid_tab) { + dragging_valid_tab = false; + update(); + } + } break; + case NOTIFICATION_DRAW: { if (tabs.is_empty()) { return; @@ -346,8 +360,6 @@ void TabBar::_notification(int p_what) { Color font_disabled_color = get_theme_color(SNAME("font_disabled_color")); Ref<Texture2D> incr = get_theme_icon(SNAME("increment")); Ref<Texture2D> decr = get_theme_icon(SNAME("decrement")); - Ref<Texture2D> incr_hl = get_theme_icon(SNAME("increment_highlight")); - Ref<Texture2D> decr_hl = get_theme_icon(SNAME("decrement_highlight")); bool rtl = is_layout_rtl(); Vector2 size = get_size(); @@ -391,7 +403,10 @@ void TabBar::_notification(int p_what) { } if (buttons_visible) { - int vofs = (get_size().height - incr->get_size().height) / 2; + Ref<Texture2D> incr_hl = get_theme_icon(SNAME("increment_highlight")); + Ref<Texture2D> decr_hl = get_theme_icon(SNAME("decrement_highlight")); + + int vofs = (size.height - incr->get_size().height) / 2; if (rtl) { if (missing_right) { @@ -419,6 +434,39 @@ void TabBar::_notification(int p_what) { } } } + + if (dragging_valid_tab) { + int x; + + int tab_hover = get_hovered_tab(); + if (tab_hover != -1) { + Rect2 tab_rect = get_tab_rect(tab_hover); + + x = tab_rect.position.x; + if (get_local_mouse_position().x > x + tab_rect.size.width / 2) { + x += tab_rect.size.width; + } + } else { + if (rtl ^ (get_local_mouse_position().x < get_tab_rect(0).position.x)) { + x = get_tab_rect(0).position.x; + if (rtl) { + x += get_tab_rect(0).size.width; + } + } else { + Rect2 tab_rect = get_tab_rect(get_tab_count() - 1); + + x = tab_rect.position.x; + if (!rtl) { + x += tab_rect.size.width; + } + } + } + + Ref<Texture2D> drop_mark = get_theme_icon(SNAME("drop_mark")); + Color drop_mark_color = get_theme_color(SNAME("drop_mark_color")); + + drop_mark->draw(get_canvas_item(), Point2(x - drop_mark->get_width() / 2, (size.height - drop_mark->get_height()) / 2), drop_mark_color); + } } break; } } @@ -906,6 +954,8 @@ void TabBar::_on_mouse_exited() { cb_hover = -1; hover = -1; highlight_arrow = -1; + dragging_valid_tab = false; + update(); } @@ -1057,13 +1107,29 @@ void TabBar::drop_data(const Point2 &p_point, const Variant &p_data) { NodePath to_path = get_path(); if (from_path == to_path) { - if (hover_now < 0) { - hover_now = get_tab_count() - 1; + if (tab_from_id == hover_now) { + return; + } + + // Drop the new tab to the left or right depending on where the target tab is being hovered. + if (hover_now != -1) { + Rect2 tab_rect = get_tab_rect(hover_now); + if (is_layout_rtl() ^ (p_point.x <= tab_rect.position.x + tab_rect.size.width / 2)) { + if (hover_now > tab_from_id) { + hover_now -= 1; + } + } else if (tab_from_id > hover_now) { + hover_now += 1; + } + } else { + hover_now = is_layout_rtl() ^ (p_point.x < get_tab_rect(0).position.x) ? 0 : get_tab_count() - 1; } move_tab(tab_from_id, hover_now); - emit_signal(SNAME("active_tab_rearranged"), hover_now); - set_current_tab(hover_now); + if (!is_tab_disabled(hover_now)) { + emit_signal(SNAME("active_tab_rearranged"), hover_now); + set_current_tab(hover_now); + } } else if (get_tabs_rearrange_group() != -1) { // Drag and drop between Tabs. @@ -1075,11 +1141,17 @@ void TabBar::drop_data(const Point2 &p_point, const Variant &p_data) { return; } - Tab moving_tab = from_tabs->tabs[tab_from_id]; - if (hover_now < 0) { - hover_now = get_tab_count(); + // Drop the new tab to the left or right depending on where the target tab is being hovered. + if (hover_now != -1) { + Rect2 tab_rect = get_tab_rect(hover_now); + if (is_layout_rtl() ^ (p_point.x > tab_rect.position.x + tab_rect.size.width / 2)) { + hover_now += 1; + } + } else { + hover_now = is_layout_rtl() ^ (p_point.x < get_tab_rect(0).position.x) ? 0 : get_tab_count(); } + Tab moving_tab = from_tabs->tabs[tab_from_id]; from_tabs->remove_tab(tab_from_id); tabs.insert(hover_now, moving_tab); @@ -1092,7 +1164,13 @@ void TabBar::drop_data(const Point2 &p_point, const Variant &p_data) { } } - set_current_tab(hover_now); + if (!is_tab_disabled(hover_now)) { + set_current_tab(hover_now); + } else { + _update_cache(); + update(); + } + update_minimum_size(); if (tabs.size() == 1) { diff --git a/scene/gui/tab_bar.h b/scene/gui/tab_bar.h index e0c4ba85ef..548a2e62af 100644 --- a/scene/gui/tab_bar.h +++ b/scene/gui/tab_bar.h @@ -101,6 +101,7 @@ private: int max_width = 0; bool scrolling_enabled = true; bool drag_to_rearrange_enabled = false; + bool dragging_valid_tab = false; bool scroll_to_selected = true; int tabs_rearrange_group = -1; diff --git a/scene/gui/tab_container.cpp b/scene/gui/tab_container.cpp index ee61c862b7..1697e743be 100644 --- a/scene/gui/tab_container.cpp +++ b/scene/gui/tab_container.cpp @@ -173,9 +173,9 @@ void TabContainer::_notification(int p_what) { int x = is_layout_rtl() ? 0 : get_size().width - menu->get_width(); if (menu_hovered) { - menu_hl->draw(get_canvas_item(), Size2(x, (header_height - menu_hl->get_height()) / 2)); + menu_hl->draw(get_canvas_item(), Point2(x, (header_height - menu_hl->get_height()) / 2)); } else { - menu->draw(get_canvas_item(), Size2(x, (header_height - menu->get_height()) / 2)); + menu->draw(get_canvas_item(), Point2(x, (header_height - menu->get_height()) / 2)); } } } break; @@ -201,6 +201,8 @@ void TabContainer::_on_theme_changed() { tab_bar->add_theme_icon_override(SNAME("increment_highlight"), get_theme_icon(SNAME("increment_highlight"))); tab_bar->add_theme_icon_override(SNAME("decrement"), get_theme_icon(SNAME("decrement"))); tab_bar->add_theme_icon_override(SNAME("decrement_highlight"), get_theme_icon(SNAME("decrement_highlight"))); + tab_bar->add_theme_icon_override(SNAME("drop_mark"), get_theme_icon(SNAME("drop_mark"))); + tab_bar->add_theme_color_override(SNAME("drop_mark_color"), get_theme_color(SNAME("drop_mark_color"))); tab_bar->add_theme_color_override(SNAME("font_selected_color"), get_theme_color(SNAME("font_selected_color"))); tab_bar->add_theme_color_override(SNAME("font_unselected_color"), get_theme_color(SNAME("font_unselected_color"))); tab_bar->add_theme_color_override(SNAME("font_disabled_color"), get_theme_color(SNAME("font_disabled_color"))); @@ -384,8 +386,6 @@ void TabContainer::_drop_data_fw(const Point2 &p_point, const Variant &p_data, C return; } - int hover_now = get_tab_idx_at_point(p_point); - Dictionary d = p_data; if (!d.has("type")) { return; @@ -393,11 +393,27 @@ void TabContainer::_drop_data_fw(const Point2 &p_point, const Variant &p_data, C if (String(d["type"]) == "tabc_element") { int tab_from_id = d["tabc_element"]; + int hover_now = get_tab_idx_at_point(p_point); NodePath from_path = d["from_path"]; NodePath to_path = get_path(); + if (from_path == to_path) { - if (hover_now < 0) { - hover_now = get_tab_count() - 1; + if (tab_from_id == hover_now) { + return; + } + + // Drop the new tab to the left or right depending on where the target tab is being hovered. + if (hover_now != -1) { + Rect2 tab_rect = tab_bar->get_tab_rect(hover_now); + if (is_layout_rtl() ^ (p_point.x <= tab_rect.position.x + tab_rect.size.width / 2)) { + if (hover_now > tab_from_id) { + hover_now -= 1; + } + } else if (tab_from_id > hover_now) { + hover_now += 1; + } + } else { + hover_now = is_layout_rtl() ^ (p_point.x < tab_bar->get_tab_rect(0).position.x) ? 0 : get_tab_count() - 1; } move_child(get_tab_control(tab_from_id), get_tab_control(hover_now)->get_index(false)); @@ -407,16 +423,31 @@ void TabContainer::_drop_data_fw(const Point2 &p_point, const Variant &p_data, C } else if (get_tabs_rearrange_group() != -1) { // Drag and drop between TabContainers. + Node *from_node = get_node(from_path); TabContainer *from_tabc = Object::cast_to<TabContainer>(from_node); + if (from_tabc && from_tabc->get_tabs_rearrange_group() == get_tabs_rearrange_group()) { + // Get the tab properties before they get erased by the child removal. + String tab_title = from_tabc->get_tab_title(tab_from_id); + bool tab_disabled = from_tabc->is_tab_disabled(tab_from_id); + + // Drop the new tab to the left or right depending on where the target tab is being hovered. + if (hover_now != -1) { + Rect2 tab_rect = tab_bar->get_tab_rect(hover_now); + if (is_layout_rtl() ^ (p_point.x > tab_rect.position.x + tab_rect.size.width / 2)) { + hover_now += 1; + } + } else { + hover_now = is_layout_rtl() ^ (p_point.x < tab_bar->get_tab_rect(0).position.x) ? 0 : get_tab_count(); + } + Control *moving_tabc = from_tabc->get_tab_control(tab_from_id); from_tabc->remove_child(moving_tabc); add_child(moving_tabc, true); - if (hover_now < 0) { - hover_now = get_tab_count() - 1; - } + set_tab_title(get_tab_count() - 1, tab_title); + set_tab_disabled(get_tab_count() - 1, tab_disabled); move_child(moving_tabc, get_tab_control(hover_now)->get_index(false)); if (!is_tab_disabled(hover_now)) { diff --git a/scene/main/http_request.cpp b/scene/main/http_request.cpp index 700ba761f6..ac10c2bad8 100644 --- a/scene/main/http_request.cpp +++ b/scene/main/http_request.cpp @@ -558,12 +558,12 @@ void HTTPRequest::set_https_proxy(const String &p_host, int p_port) { client->set_https_proxy(p_host, p_port); } -void HTTPRequest::set_timeout(int p_timeout) { +void HTTPRequest::set_timeout(double p_timeout) { ERR_FAIL_COND(p_timeout < 0); timeout = p_timeout; } -int HTTPRequest::get_timeout() { +double HTTPRequest::get_timeout() { return timeout; } @@ -615,7 +615,7 @@ void HTTPRequest::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::BOOL, "accept_gzip"), "set_accept_gzip", "is_accepting_gzip"); ADD_PROPERTY(PropertyInfo(Variant::INT, "body_size_limit", PROPERTY_HINT_RANGE, "-1,2000000000"), "set_body_size_limit", "get_body_size_limit"); ADD_PROPERTY(PropertyInfo(Variant::INT, "max_redirects", PROPERTY_HINT_RANGE, "-1,64"), "set_max_redirects", "get_max_redirects"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "timeout", PROPERTY_HINT_RANGE, "0,86400"), "set_timeout", "get_timeout"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "timeout", PROPERTY_HINT_RANGE, "0,3600,0.1,or_greater"), "set_timeout", "get_timeout"); ADD_SIGNAL(MethodInfo("request_completed", PropertyInfo(Variant::INT, "result"), PropertyInfo(Variant::INT, "response_code"), PropertyInfo(Variant::PACKED_STRING_ARRAY, "headers"), PropertyInfo(Variant::PACKED_BYTE_ARRAY, "body"))); diff --git a/scene/main/http_request.h b/scene/main/http_request.h index 62880fa282..26d648458f 100644 --- a/scene/main/http_request.h +++ b/scene/main/http_request.h @@ -96,7 +96,7 @@ private: int max_redirects = 8; - int timeout = 0; + double timeout = 0; void _redirect_request(const String &p_new_url); @@ -146,8 +146,8 @@ public: Timer *timer; - void set_timeout(int p_timeout); - int get_timeout(); + void set_timeout(double p_timeout); + double get_timeout(); void _timeout(); diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp index ec33e5752e..0c7a9fda4a 100644 --- a/scene/main/viewport.cpp +++ b/scene/main/viewport.cpp @@ -1124,9 +1124,9 @@ Vector2 Viewport::get_mouse_position() const { return gui.last_mouse_pos; } -void Viewport::warp_mouse(const Vector2 &p_pos) { - Vector2 gpos = (get_final_transform().affine_inverse() * _get_input_pre_xform()).affine_inverse().xform(p_pos); - Input::get_singleton()->warp_mouse_position(gpos); +void Viewport::warp_mouse(const Vector2 &p_position) { + Vector2 gpos = (get_final_transform().affine_inverse() * _get_input_pre_xform()).affine_inverse().xform(p_position); + Input::get_singleton()->warp_mouse(gpos); } void Viewport::_gui_sort_roots() { @@ -2001,30 +2001,58 @@ void Viewport::_gui_input_event(Ref<InputEvent> p_event) { if (from && p_event->is_pressed()) { Control *next = nullptr; - if (p_event->is_action_pressed("ui_focus_next", true, true)) { - next = from->find_next_valid_focus(); - } + Ref<InputEventJoypadMotion> joypadmotion_event = p_event; + if (joypadmotion_event.is_valid()) { + Input *input = Input::get_singleton(); - if (p_event->is_action_pressed("ui_focus_prev", true, true)) { - next = from->find_prev_valid_focus(); - } + if (p_event->is_action_pressed("ui_focus_next") && input->is_action_just_pressed("ui_focus_next")) { + next = from->find_next_valid_focus(); + } - if (p_event->is_action_pressed("ui_up", true, true)) { - next = from->_get_focus_neighbor(SIDE_TOP); - } + if (p_event->is_action_pressed("ui_focus_prev") && input->is_action_just_pressed("ui_focus_prev")) { + next = from->find_prev_valid_focus(); + } - if (p_event->is_action_pressed("ui_left", true, true)) { - next = from->_get_focus_neighbor(SIDE_LEFT); - } + if (p_event->is_action_pressed("ui_up") && input->is_action_just_pressed("ui_up")) { + next = from->_get_focus_neighbor(SIDE_TOP); + } - if (p_event->is_action_pressed("ui_right", true, true)) { - next = from->_get_focus_neighbor(SIDE_RIGHT); - } + if (p_event->is_action_pressed("ui_left") && input->is_action_just_pressed("ui_left")) { + next = from->_get_focus_neighbor(SIDE_LEFT); + } - if (p_event->is_action_pressed("ui_down", true, true)) { - next = from->_get_focus_neighbor(SIDE_BOTTOM); - } + if (p_event->is_action_pressed("ui_right") && input->is_action_just_pressed("ui_right")) { + next = from->_get_focus_neighbor(SIDE_RIGHT); + } + if (p_event->is_action_pressed("ui_down") && input->is_action_just_pressed("ui_down")) { + next = from->_get_focus_neighbor(SIDE_BOTTOM); + } + } else { + if (p_event->is_action_pressed("ui_focus_next", true, true)) { + next = from->find_next_valid_focus(); + } + + if (p_event->is_action_pressed("ui_focus_prev", true, true)) { + next = from->find_prev_valid_focus(); + } + + if (p_event->is_action_pressed("ui_up", true, true)) { + next = from->_get_focus_neighbor(SIDE_TOP); + } + + if (p_event->is_action_pressed("ui_left", true, true)) { + next = from->_get_focus_neighbor(SIDE_LEFT); + } + + if (p_event->is_action_pressed("ui_right", true, true)) { + next = from->_get_focus_neighbor(SIDE_RIGHT); + } + + if (p_event->is_action_pressed("ui_down", true, true)) { + next = from->_get_focus_neighbor(SIDE_BOTTOM); + } + } if (next) { next->grab_focus(); set_input_as_handled(); @@ -2691,7 +2719,7 @@ void Viewport::push_input(const Ref<InputEvent> &p_event, bool p_local_coords) { ev = p_event; } - if (is_embedding_subwindows() && _sub_windows_forward_input(p_event)) { + if (is_embedding_subwindows() && _sub_windows_forward_input(ev)) { set_input_as_handled(); return; } @@ -3614,7 +3642,7 @@ void Viewport::_bind_methods() { ClassDB::bind_method(D_METHOD("is_audio_listener_2d"), &Viewport::is_audio_listener_2d); ClassDB::bind_method(D_METHOD("get_mouse_position"), &Viewport::get_mouse_position); - ClassDB::bind_method(D_METHOD("warp_mouse", "to_position"), &Viewport::warp_mouse); + ClassDB::bind_method(D_METHOD("warp_mouse", "position"), &Viewport::warp_mouse); ClassDB::bind_method(D_METHOD("gui_get_drag_data"), &Viewport::gui_get_drag_data); ClassDB::bind_method(D_METHOD("gui_is_dragging"), &Viewport::gui_is_dragging); diff --git a/scene/main/viewport.h b/scene/main/viewport.h index e4912f31c5..d5fca1b881 100644 --- a/scene/main/viewport.h +++ b/scene/main/viewport.h @@ -547,7 +547,7 @@ public: bool is_input_disabled() const; Vector2 get_mouse_position() const; - void warp_mouse(const Vector2 &p_pos); + void warp_mouse(const Vector2 &p_position); void set_physics_object_picking(bool p_enable); bool get_physics_object_picking(); diff --git a/scene/resources/capsule_shape_2d.cpp b/scene/resources/capsule_shape_2d.cpp index a1ad487bff..c7bd4cb698 100644 --- a/scene/resources/capsule_shape_2d.cpp +++ b/scene/resources/capsule_shape_2d.cpp @@ -109,8 +109,8 @@ void CapsuleShape2D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_height", "height"), &CapsuleShape2D::set_height); ClassDB::bind_method(D_METHOD("get_height"), &CapsuleShape2D::get_height); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius"), "set_radius", "get_radius"); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height"), "set_height", "get_height"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_radius", "get_radius"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_height", "get_height"); ADD_LINKED_PROPERTY("radius", "height"); ADD_LINKED_PROPERTY("height", "radius"); } diff --git a/scene/resources/capsule_shape_3d.cpp b/scene/resources/capsule_shape_3d.cpp index 2179ce82dd..d708706ff2 100644 --- a/scene/resources/capsule_shape_3d.cpp +++ b/scene/resources/capsule_shape_3d.cpp @@ -29,6 +29,7 @@ /*************************************************************************/ #include "capsule_shape_3d.h" + #include "servers/physics_server_3d.h" Vector<Vector3> CapsuleShape3D::get_debug_mesh_lines() const { @@ -112,8 +113,8 @@ void CapsuleShape3D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_height", "height"), &CapsuleShape3D::set_height); ClassDB::bind_method(D_METHOD("get_height"), &CapsuleShape3D::get_height); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.001,4096,0.001"), "set_radius", "get_radius"); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height", PROPERTY_HINT_RANGE, "0.001,4096,0.001"), "set_height", "get_height"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_radius", "get_radius"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_height", "get_height"); ADD_LINKED_PROPERTY("radius", "height"); ADD_LINKED_PROPERTY("height", "radius"); } diff --git a/scene/resources/circle_shape_2d.cpp b/scene/resources/circle_shape_2d.cpp index de931fca7e..c287de9ede 100644 --- a/scene/resources/circle_shape_2d.cpp +++ b/scene/resources/circle_shape_2d.cpp @@ -56,7 +56,7 @@ void CircleShape2D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_radius", "radius"), &CircleShape2D::set_radius); ClassDB::bind_method(D_METHOD("get_radius"), &CircleShape2D::get_radius); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.01,16384,0.5"), "set_radius", "get_radius"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_radius", "get_radius"); } Rect2 CircleShape2D::get_rect() const { diff --git a/scene/resources/cylinder_shape_3d.cpp b/scene/resources/cylinder_shape_3d.cpp index c4f1cba341..a1fe5c46fb 100644 --- a/scene/resources/cylinder_shape_3d.cpp +++ b/scene/resources/cylinder_shape_3d.cpp @@ -29,6 +29,7 @@ /*************************************************************************/ #include "cylinder_shape_3d.h" + #include "servers/physics_server_3d.h" Vector<Vector3> CylinderShape3D::get_debug_mesh_lines() const { @@ -99,8 +100,8 @@ void CylinderShape3D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_height", "height"), &CylinderShape3D::set_height); ClassDB::bind_method(D_METHOD("get_height"), &CylinderShape3D::get_height); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.001,4096,0.001"), "set_radius", "get_radius"); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height", PROPERTY_HINT_RANGE, "0.001,4096,0.001"), "set_height", "get_height"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "height", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_height", "get_height"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_radius", "get_radius"); } CylinderShape3D::CylinderShape3D() : diff --git a/scene/resources/default_theme/default_theme.cpp b/scene/resources/default_theme/default_theme.cpp index da37228ed9..eb71401a3a 100644 --- a/scene/resources/default_theme/default_theme.cpp +++ b/scene/resources/default_theme/default_theme.cpp @@ -801,6 +801,7 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const theme->set_icon("increment_highlight", "TabContainer", icons["scroll_button_right_hl"]); theme->set_icon("decrement", "TabContainer", icons["scroll_button_left"]); theme->set_icon("decrement_highlight", "TabContainer", icons["scroll_button_left_hl"]); + theme->set_icon("drop_mark", "TabContainer", icons["tabs_drop_mark"]); theme->set_icon("menu", "TabContainer", icons["tabs_menu"]); theme->set_icon("menu_highlight", "TabContainer", icons["tabs_menu_hl"]); @@ -811,6 +812,7 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const theme->set_color("font_unselected_color", "TabContainer", control_font_low_color); theme->set_color("font_disabled_color", "TabContainer", control_font_disabled_color); theme->set_color("font_outline_color", "TabContainer", Color(1, 1, 1)); + theme->set_color("drop_mark_color", "TabContainer", Color(1, 1, 1)); theme->set_constant("side_margin", "TabContainer", 8 * scale); theme->set_constant("icon_separation", "TabContainer", 4 * scale); @@ -828,6 +830,7 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const theme->set_icon("increment_highlight", "TabBar", icons["scroll_button_right_hl"]); theme->set_icon("decrement", "TabBar", icons["scroll_button_left"]); theme->set_icon("decrement_highlight", "TabBar", icons["scroll_button_left_hl"]); + theme->set_icon("drop_mark", "TabBar", icons["tabs_drop_mark"]); theme->set_icon("close", "TabBar", icons["close"]); theme->set_font("font", "TabBar", Ref<Font>()); @@ -837,6 +840,7 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const theme->set_color("font_unselected_color", "TabBar", control_font_low_color); theme->set_color("font_disabled_color", "TabBar", control_font_disabled_color); theme->set_color("font_outline_color", "TabBar", Color(1, 1, 1)); + theme->set_color("drop_mark_color", "TabBar", Color(1, 1, 1)); theme->set_constant("hseparation", "TabBar", 4 * scale); theme->set_constant("outline_size", "TabBar", 0); diff --git a/scene/resources/default_theme/tabs_drop_mark.svg b/scene/resources/default_theme/tabs_drop_mark.svg new file mode 100644 index 0000000000..b1415bec45 --- /dev/null +++ b/scene/resources/default_theme/tabs_drop_mark.svg @@ -0,0 +1 @@ +<svg height="32" viewBox="0 0 16 32" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m5 1h6v30h-6z" fill="#d3d3d3"/></svg> diff --git a/scene/resources/height_map_shape_3d.cpp b/scene/resources/height_map_shape_3d.cpp index 121930d86f..824dc4a544 100644 --- a/scene/resources/height_map_shape_3d.cpp +++ b/scene/resources/height_map_shape_3d.cpp @@ -29,6 +29,7 @@ /*************************************************************************/ #include "height_map_shape_3d.h" + #include "servers/physics_server_3d.h" Vector<Vector3> HeightMapShape3D::get_debug_mesh_lines() const { @@ -186,8 +187,8 @@ void HeightMapShape3D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_map_data", "data"), &HeightMapShape3D::set_map_data); ClassDB::bind_method(D_METHOD("get_map_data"), &HeightMapShape3D::get_map_data); - ADD_PROPERTY(PropertyInfo(Variant::INT, "map_width", PROPERTY_HINT_RANGE, "1,4096,1"), "set_map_width", "get_map_width"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "map_depth", PROPERTY_HINT_RANGE, "1,4096,1"), "set_map_depth", "get_map_depth"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "map_width", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_map_width", "get_map_width"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "map_depth", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_map_depth", "get_map_depth"); ADD_PROPERTY(PropertyInfo(Variant::PACKED_FLOAT32_ARRAY, "map_data"), "set_map_data", "get_map_data"); } diff --git a/scene/resources/separation_ray_shape_2d.cpp b/scene/resources/separation_ray_shape_2d.cpp index 0406c91b70..df7b0d969a 100644 --- a/scene/resources/separation_ray_shape_2d.cpp +++ b/scene/resources/separation_ray_shape_2d.cpp @@ -89,7 +89,7 @@ void SeparationRayShape2D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_slide_on_slope", "active"), &SeparationRayShape2D::set_slide_on_slope); ClassDB::bind_method(D_METHOD("get_slide_on_slope"), &SeparationRayShape2D::get_slide_on_slope); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length"), "set_length", "get_length"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_length", "get_length"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_slope"), "set_slide_on_slope", "get_slide_on_slope"); } diff --git a/scene/resources/separation_ray_shape_3d.cpp b/scene/resources/separation_ray_shape_3d.cpp index 5aa7616589..736cb60c1c 100644 --- a/scene/resources/separation_ray_shape_3d.cpp +++ b/scene/resources/separation_ray_shape_3d.cpp @@ -80,7 +80,7 @@ void SeparationRayShape3D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_slide_on_slope", "active"), &SeparationRayShape3D::set_slide_on_slope); ClassDB::bind_method(D_METHOD("get_slide_on_slope"), &SeparationRayShape3D::get_slide_on_slope); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "0,4096,0.001"), "set_length", "get_length"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_length", "get_length"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_slope"), "set_slide_on_slope", "get_slide_on_slope"); } diff --git a/scene/resources/sphere_shape_3d.cpp b/scene/resources/sphere_shape_3d.cpp index 8282992401..8de0dc1650 100644 --- a/scene/resources/sphere_shape_3d.cpp +++ b/scene/resources/sphere_shape_3d.cpp @@ -29,6 +29,7 @@ /*************************************************************************/ #include "sphere_shape_3d.h" + #include "servers/physics_server_3d.h" Vector<Vector3> SphereShape3D::get_debug_mesh_lines() const { @@ -77,7 +78,7 @@ void SphereShape3D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_radius", "radius"), &SphereShape3D::set_radius); ClassDB::bind_method(D_METHOD("get_radius"), &SphereShape3D::get_radius); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0,4096,0.001"), "set_radius", "get_radius"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "radius", PROPERTY_HINT_RANGE, "0.001,100,0.001,or_greater"), "set_radius", "get_radius"); } SphereShape3D::SphereShape3D() : diff --git a/scene/resources/world_boundary_shape_2d.cpp b/scene/resources/world_boundary_shape_2d.cpp index 9789388c6a..ac5be79d24 100644 --- a/scene/resources/world_boundary_shape_2d.cpp +++ b/scene/resources/world_boundary_shape_2d.cpp @@ -108,7 +108,7 @@ void WorldBoundaryShape2D::_bind_methods() { ClassDB::bind_method(D_METHOD("get_distance"), &WorldBoundaryShape2D::get_distance); ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "normal"), "set_normal", "get_normal"); - ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "distance"), "set_distance", "get_distance"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "distance", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_distance", "get_distance"); } WorldBoundaryShape2D::WorldBoundaryShape2D() : diff --git a/servers/display_server.cpp b/servers/display_server.cpp index db65465c64..67bfc75426 100644 --- a/servers/display_server.cpp +++ b/servers/display_server.cpp @@ -228,7 +228,7 @@ DisplayServer::MouseMode DisplayServer::mouse_get_mode() const { return MOUSE_MODE_VISIBLE; } -void DisplayServer::mouse_warp_to_position(const Point2i &p_to) { +void DisplayServer::warp_mouse(const Point2i &p_position) { WARN_PRINT("Mouse warping is not supported by this display server."); } @@ -481,7 +481,7 @@ void DisplayServer::_bind_methods() { ClassDB::bind_method(D_METHOD("mouse_set_mode", "mouse_mode"), &DisplayServer::mouse_set_mode); ClassDB::bind_method(D_METHOD("mouse_get_mode"), &DisplayServer::mouse_get_mode); - ClassDB::bind_method(D_METHOD("mouse_warp_to_position", "position"), &DisplayServer::mouse_warp_to_position); + ClassDB::bind_method(D_METHOD("warp_mouse", "position"), &DisplayServer::warp_mouse); ClassDB::bind_method(D_METHOD("mouse_get_position"), &DisplayServer::mouse_get_position); ClassDB::bind_method(D_METHOD("mouse_get_button_state"), &DisplayServer::mouse_get_button_state); @@ -729,7 +729,7 @@ Input::MouseMode DisplayServer::_input_get_mouse_mode() { } void DisplayServer::_input_warp(const Vector2 &p_to_pos) { - singleton->mouse_warp_to_position(p_to_pos); + singleton->warp_mouse(p_to_pos); } Input::CursorShape DisplayServer::_input_get_current_cursor_shape() { diff --git a/servers/display_server.h b/servers/display_server.h index f3a910471f..4961b07ba3 100644 --- a/servers/display_server.h +++ b/servers/display_server.h @@ -183,7 +183,7 @@ public: virtual void mouse_set_mode(MouseMode p_mode); virtual MouseMode mouse_get_mode() const; - virtual void mouse_warp_to_position(const Point2i &p_to); + virtual void warp_mouse(const Point2i &p_position); virtual Point2i mouse_get_position() const; virtual MouseButton mouse_get_button_state() const; diff --git a/servers/extensions/SCsub b/servers/extensions/SCsub index eac66ea283..ba73353f2a 100644 --- a/servers/extensions/SCsub +++ b/servers/extensions/SCsub @@ -2,11 +2,6 @@ Import("env") -import make_wrappers -from platform_methods import run_in_subprocess - -env.CommandNoCache(["ext_wrappers.gen.inc"], "make_wrappers.py", run_in_subprocess(make_wrappers.run)) - env_object = env.Clone() env_object.add_source_files(env.servers_sources, "*.cpp") diff --git a/servers/extensions/physics_server_3d_extension.h b/servers/extensions/physics_server_3d_extension.h index b40ab8a295..41a7746183 100644 --- a/servers/extensions/physics_server_3d_extension.h +++ b/servers/extensions/physics_server_3d_extension.h @@ -31,11 +31,11 @@ #ifndef PHYSICS_SERVER_3D_EXTENSION_H #define PHYSICS_SERVER_3D_EXTENSION_H +#include "core/extension/ext_wrappers.gen.inc" #include "core/object/script_language.h" #include "core/variant/native_ptr.h" #include "core/variant/type_info.h" #include "core/variant/typed_array.h" -#include "servers/extensions/ext_wrappers.gen.inc" #include "servers/physics_server_3d.h" class PhysicsDirectBodyState3DExtension : public PhysicsDirectBodyState3D { diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp index 08f1ced803..a6f3a48398 100644 --- a/servers/rendering/shader_language.cpp +++ b/servers/rendering/shader_language.cpp @@ -9034,7 +9034,7 @@ Error ShaderLanguage::compile(const String &p_code, const ShaderCompileInfo &p_i return OK; } -Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint) { +Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint) { clear(); code = p_code; @@ -9053,7 +9053,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ } break; case COMPLETION_SHADER_TYPE: { for (const String &shader_type : p_info.shader_types) { - ScriptCodeCompletionOption option(shader_type, ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(shader_type, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_options->push_back(option); } return OK; @@ -9073,7 +9073,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (!found) { for (int j = 0; j < info.options.size(); j++) { - ScriptCodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_options->push_back(option); } } @@ -9081,7 +9081,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ const String name = String(info.name); if (!shader->render_modes.has(name)) { - ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_options->push_back(option); } } @@ -9093,7 +9093,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (shader->structs.has(completion_struct)) { StructNode *node = shader->structs[completion_struct].shader_struct; for (int i = 0; i < node->members.size(); i++) { - ScriptCodeCompletionOption option(node->members[i]->name, ScriptCodeCompletionOption::KIND_MEMBER); + ScriptLanguage::CodeCompletionOption option(node->members[i]->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); r_options->push_back(option); } } @@ -9115,7 +9115,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (found) { continue; } - ScriptCodeCompletionOption option(E.key, ScriptCodeCompletionOption::KIND_FUNCTION); + ScriptLanguage::CodeCompletionOption option(E.key, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); r_options->push_back(option); } @@ -9124,7 +9124,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ case COMPLETION_IDENTIFIER: case COMPLETION_FUNCTION_CALL: { bool comp_ident = completion_type == COMPLETION_IDENTIFIER; - Map<String, ScriptCodeCompletionOption::Kind> matches; + Map<String, ScriptLanguage::CodeCompletionKind> matches; StringName skip_function; BlockNode *block = completion_block; @@ -9133,7 +9133,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (comp_ident) { for (const KeyValue<StringName, BlockNode::Variable> &E : block->variables) { if (E.value.line < completion_line) { - matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE); + matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE); } } } @@ -9141,7 +9141,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (block->parent_function) { if (comp_ident) { for (int i = 0; i < block->parent_function->arguments.size(); i++) { - matches.insert(block->parent_function->arguments[i].name, ScriptCodeCompletionOption::KIND_VARIABLE); + matches.insert(block->parent_function->arguments[i].name, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE); } } skip_function = block->parent_function->name; @@ -9152,9 +9152,9 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (comp_ident) { if (p_info.functions.has("global")) { for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["global"].built_ins) { - ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER; + ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER; if (E.value.constant) { - kind = ScriptCodeCompletionOption::KIND_CONSTANT; + kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT; } matches.insert(E.key, kind); } @@ -9162,9 +9162,9 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (p_info.functions.has("constants")) { for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["constants"].built_ins) { - ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER; + ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER; if (E.value.constant) { - kind = ScriptCodeCompletionOption::KIND_CONSTANT; + kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT; } matches.insert(E.key, kind); } @@ -9172,22 +9172,22 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (skip_function != StringName() && p_info.functions.has(skip_function)) { for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions[skip_function].built_ins) { - ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER; + ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER; if (E.value.constant) { - kind = ScriptCodeCompletionOption::KIND_CONSTANT; + kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT; } matches.insert(E.key, kind); } } for (const KeyValue<StringName, ShaderNode::Constant> &E : shader->constants) { - matches.insert(E.key, ScriptCodeCompletionOption::KIND_CONSTANT); + matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT); } for (const KeyValue<StringName, ShaderNode::Varying> &E : shader->varyings) { - matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE); + matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE); } for (const KeyValue<StringName, ShaderNode::Uniform> &E : shader->uniforms) { - matches.insert(E.key, ScriptCodeCompletionOption::KIND_MEMBER); + matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER); } } @@ -9195,7 +9195,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (!shader->functions[i].callable || shader->functions[i].name == skip_function) { continue; } - matches.insert(String(shader->functions[i].name), ScriptCodeCompletionOption::KIND_FUNCTION); + matches.insert(String(shader->functions[i].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); } int idx = 0; @@ -9203,7 +9203,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ if (stages && stages->has(skip_function)) { for (const KeyValue<StringName, StageFunctionInfo> &E : (*stages)[skip_function].stage_functions) { - matches.insert(String(E.key), ScriptCodeCompletionOption::KIND_FUNCTION); + matches.insert(String(E.key), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); } } @@ -9212,7 +9212,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ idx++; continue; } - matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION); + matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); idx++; } @@ -9226,15 +9226,15 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ continue; } if (builtin_func_defs[idx].tag == completion_class) { - matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION); + matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION); } idx++; } } - for (const KeyValue<String, ScriptCodeCompletionOption::Kind> &E : matches) { - ScriptCodeCompletionOption option(E.key, E.value); - if (E.value == ScriptCodeCompletionOption::KIND_FUNCTION) { + for (const KeyValue<String, ScriptLanguage::CodeCompletionKind> &E : matches) { + ScriptLanguage::CodeCompletionOption option(E.key, E.value); + if (E.value == ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION) { option.insert_text += "("; } r_options->push_back(option); @@ -9483,18 +9483,18 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ } for (int i = 0; i < limit; i++) { - r_options->push_back(ScriptCodeCompletionOption(String::chr(colv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT)); - r_options->push_back(ScriptCodeCompletionOption(String::chr(coordv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT)); - r_options->push_back(ScriptCodeCompletionOption(String::chr(coordt[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT)); + r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(colv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT)); + r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT)); + r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordt[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT)); } } break; case COMPLETION_HINT: { if (completion_base == DataType::TYPE_VEC4) { - ScriptCodeCompletionOption option("hint_color", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option("hint_color", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_options->push_back(option); } else if ((completion_base == DataType::TYPE_INT || completion_base == DataType::TYPE_FLOAT) && !completion_base_array) { - ScriptCodeCompletionOption option("hint_range", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option("hint_range", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); if (completion_base == DataType::TYPE_INT) { option.insert_text = "hint_range(0, 100, 1)"; @@ -9530,12 +9530,12 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_ } for (int i = 0; i < options.size(); i++) { - ScriptCodeCompletionOption option(options[i], ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option(options[i], ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); r_options->push_back(option); } } if (!completion_base_array) { - ScriptCodeCompletionOption option("instance_index", ScriptCodeCompletionOption::KIND_PLAIN_TEXT); + ScriptLanguage::CodeCompletionOption option("instance_index", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT); option.insert_text = "instance_index(0)"; r_options->push_back(option); } diff --git a/servers/rendering/shader_language.h b/servers/rendering/shader_language.h index f39b21621d..e5ac14a7db 100644 --- a/servers/rendering/shader_language.h +++ b/servers/rendering/shader_language.h @@ -1091,7 +1091,7 @@ public: }; Error compile(const String &p_code, const ShaderCompileInfo &p_info); - Error complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint); + Error complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint); String get_error_text(); int get_error_line(); diff --git a/tests/core/math/test_color.h b/tests/core/math/test_color.h index 702f17a9cf..6f40f8ecc0 100644 --- a/tests/core/math/test_color.h +++ b/tests/core/math/test_color.h @@ -144,6 +144,24 @@ TEST_CASE("[Color] Conversion methods") { "The string representation should match the expected value."); } +TEST_CASE("[Color] Linear <-> sRGB conversion") { + const Color color = Color(0.35, 0.5, 0.6, 0.7); + const Color color_linear = color.to_linear(); + const Color color_srgb = color.to_srgb(); + CHECK_MESSAGE( + color_linear.is_equal_approx(Color(0.100481, 0.214041, 0.318547, 0.7)), + "The color converted to linear color space should match the expected value."); + CHECK_MESSAGE( + color_srgb.is_equal_approx(Color(0.62621, 0.735357, 0.797738, 0.7)), + "The color converted to sRGB color space should match the expected value."); + CHECK_MESSAGE( + color_linear.to_srgb().is_equal_approx(Color(0.35, 0.5, 0.6, 0.7)), + "The linear color converted back to sRGB color space should match the expected value."); + CHECK_MESSAGE( + color_srgb.to_linear().is_equal_approx(Color(0.35, 0.5, 0.6, 0.7)), + "The sRGB color converted back to linear color space should match the expected value."); +} + TEST_CASE("[Color] Named colors") { CHECK_MESSAGE( Color::named("red").is_equal_approx(Color::hex(0xFF0000FF)), |
