asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/modules/mono/csharp_script.h

602 lines
22 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* csharp_script.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
Added mono module
2017-10-02 23:24:00 +02:00
#ifndef CSHARP_SCRIPT_H
#define CSHARP_SCRIPT_H
Style: Harmonize header includes in modules This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module ("local" includes) should be listed first in their own block using relative paths, before Godot's "core" includes which use "absolute" (project folder relative) paths, and finally thirdparty includes. Includes in `#ifdef`s come after their relevant section, i.e. the overall structure is: - Local includes * Conditional local includes - Core includes * Conditional core includes - Thirdparty includes * Conditional thirdparty includes
2023-06-13 16:56:21 +02:00
#include "mono_gc_handle.h"
#include "mono_gd/gd_mono.h"
Refactor DocData into core and editor (DocTools) parts
2020-11-29 04:42:06 +01:00
#include "core/doc_data.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/io/resource_loader.h"
#include "core/io/resource_saver.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/object/script_language.h"
#include "core/templates/self_list.h"
Added mono module
2017-10-02 23:24:00 +02:00
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
#ifdef TOOLS_ENABLED
#include "editor/editor_plugin.h"
#endif
Added mono module
2017-10-02 23:24:00 +02:00
class CSharpScript;
class CSharpInstance;
class CSharpLanguage;
template <typename TScriptInstance, typename TScriptLanguage>
TScriptInstance *cast_script_instance(ScriptInstance *p_inst) {
return dynamic_cast<TScriptInstance *>(p_inst);
}
#define CAST_CSHARP_INSTANCE(m_inst) (cast_script_instance<CSharpInstance, CSharpLanguage>(m_inst))
class CSharpScript : public Script {
Made use of semicolons more consitent, fixed formatting
2019-03-19 19:35:57 +01:00
GDCLASS(CSharpScript, Script);
Added mono module
2017-10-02 23:24:00 +02:00
friend class CSharpInstance;
friend class CSharpLanguage;
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
public:
struct TypeInfo {
/**
* Name of the C# class.
*/
String class_name;
/**
* Path to the icon that will be used for this class by the editor.
*/
String icon_path;
/**
* Script is marked as tool and runs in the editor.
*/
bool is_tool = false;
/**
* Script is marked as global class and will be registered in the editor.
* Registered classes can be created using certain editor dialogs and
* can be referenced by name from other languages that support the feature.
*/
bool is_global_class = false;
/**
* Script is declared abstract.
*/
bool is_abstract = false;
/**
* The C# type that corresponds to this script is a constructed generic type.
* E.g.: `Dictionary<int, string>`
*/
bool is_constructed_generic_type = false;
/**
* The C# type that corresponds to this script is a generic type definition.
* E.g.: `Dictionary<,>`
*/
bool is_generic_type_definition = false;
/**
* The C# type that corresponds to this script contains generic type parameters,
* regardless of whether the type parameters are bound or not.
*/
bool is_generic() const {
return is_constructed_generic_type || is_generic_type_definition;
}
/**
* Check if the script can be instantiated.
* C# types can't be instantiated if they are abstract or contain generic
* type parameters, but a CSharpScript is still created for them.
*/
bool can_instantiate() const {
return !is_abstract && !is_generic_type_definition;
}
};
private:
/**
* Contains the C# type information for this script.
*/
TypeInfo type_info;
/**
* Scripts are valid when the corresponding C# class is found and used
* to extract the script info using the [update_script_class_info] method.
*/
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
bool valid = false;
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
/**
* Scripts extract info from the C# class in the reload methods but,
* if the reload is not invalidated, then the current extracted info
* is still valid and there's no need to reload again.
*/
C# script reload fixed Co-authored-by: Michael Bickel <mib@developium.net> Co-authored-by: Germanrc <german_1995a@hotmail.com>
2021-12-06 19:45:59 +01:00
bool reload_invalidated = false;
Added mono module
2017-10-02 23:24:00 +02:00
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
/**
* Base script that this script derives from, or null if it derives from a
* native Godot class.
*/
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
Ref<CSharpScript> base_script;
Added mono module
2017-10-02 23:24:00 +02:00
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<Object *> instances;
Added mono module
2017-10-02 23:24:00 +02:00
Mono: Fix hot reload build errors and cleanup
2019-01-22 18:33:36 +01:00
#ifdef GD_MONO_HOT_RELOAD
C#: Improve tool script support and fix reloading issues
2018-11-30 20:43:06 +01:00
struct StateBackup {
// TODO
// Replace with buffer containing the serialized state of managed scripts.
// Keep variant state backup to use only with script instance placeholders.
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 07:33:00 +01:00
List<Pair<StringName, Variant>> properties;
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
Dictionary event_signals;
C#: Improve tool script support and fix reloading issues
2018-11-30 20:43:06 +01:00
};
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<ObjectID> pending_reload_instances;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
RBMap<ObjectID, StateBackup> pending_reload_state;
C#: Create script instance of reloaded scripts even if they're not tools Scripts that are instantiated at some point will always be recreated if they ever become placeholders to prevent non-tool scripts instantiated manually by users to become placeholders, if they do become placeholders due to errors that prevent instantiation (such as a missing parameterless constructor) these scripts will also be recreated replacing the temporary placeholder. If a script is marked as a tool but becomes a non-tool script in a rebuild, the script will become a placeholder and will no longer be considered applicable to be replaced by an instance since the user explicitly removed the Tool attribute.
2022-09-02 22:31:56 +02:00
bool was_tool_before_reload = false;
HashSet<ObjectID> pending_replace_placeholders;
C#: Improve tool script support and fix reloading issues
2018-11-30 20:43:06 +01:00
#endif
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
/**
* Script source code.
*/
Added mono module
2017-10-02 23:24:00 +02:00
String source;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
SelfList<CSharpScript> script_list = this;
implement signal related methods in csharp_script so signals can be used with emit
2018-01-18 23:27:43 +01:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Dictionary rpc_config;
Optmized data sent during RPC and RSet calls. - Now is sent the method ID rather the full function name. - The passed IDs (Node and Method) are compressed so to use less possible space. - The variant (INT and BOOL) is now encoded and compressed so to use much less data. - Optimized RPCMode retrieval for GDScript functions. - Added checksum to assert the methods are the same across peers. This work has been kindly sponsored by IMVU.
2020-02-12 11:51:50 +01:00
C#: Add source generator for signals as events Changed the signal declaration signal to: ``` // The following generates a MySignal event [Signal] public delegate void MySignalEventHandler(int param); ```
2022-07-28 17:41:47 +02:00
struct EventSignalInfo {
StringName name; // MethodInfo stores a string...
MethodInfo method_info;
};
C#: Add source generator for method list
2022-07-28 17:41:48 +02:00
struct CSharpMethodInfo {
StringName name; // MethodInfo stores a string...
MethodInfo method_info;
};
C#: Add source generator for signals as events Changed the signal declaration signal to: ``` // The following generates a MySignal event [Signal] public delegate void MySignalEventHandler(int param); ```
2022-07-28 17:41:47 +02:00
Vector<EventSignalInfo> event_signals;
C#: Add source generator for method list
2022-07-28 17:41:48 +02:00
Vector<CSharpMethodInfo> methods;
C#: Add source generator for signals as events Changed the signal declaration signal to: ``` // The following generates a MySignal event [Signal] public delegate void MySignalEventHandler(int param); ```
2022-07-28 17:41:47 +02:00
Added mono module
2017-10-02 23:24:00 +02:00
#ifdef TOOLS_ENABLED
List<PropertyInfo> exported_members_cache; // members_cache
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, Variant> exported_members_defval_cache; // member_default_values_cache
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<PlaceHolderScriptInstance *> placeholders;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
bool source_changed_cache = false;
bool placeholder_fallback_enabled = false;
bool exports_invalidated = true;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
void _update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames);
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override;
Added mono module
2017-10-02 23:24:00 +02:00
#endif
Mono/C#: Fix values not updated in remote inspector
2020-05-22 00:58:34 +02:00
#if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED)
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<StringName> exported_members_names;
Mono/C#: Fix values not updated in remote inspector
2020-05-22 00:58:34 +02:00
#endif
Add a new HashMap implementation Adds a new, cleaned up, HashMap implementation. * Uses Robin Hood Hashing (https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing). * Keeps elements in a double linked list for simpler, ordered, iteration. * Allows keeping iterators for later use in removal (Unlike Map<>, it does not do much for performance vs keeping the key, but helps replace old code). * Uses a more modern C++ iterator API, deprecates the old one. * Supports custom allocator (in case there is a wish to use a paged one). This class aims to unify all the associative template usage and replace it by this one: * Map<> (whereas key order does not matter, which is 99% of cases) * HashMap<> * OrderedHashMap<> * OAHashMap<>
2022-05-08 10:09:19 +02:00
HashMap<StringName, PropertyInfo> member_info;
Added mono module
2017-10-02 23:24:00 +02:00
void _clear();
C#: Fix module builds for Windows 32-bit with mingw-w64 The lambda was giving issues, so I re-wrote it as a static function.
2022-09-08 20:13:49 +02:00
static void GD_CLR_STDCALL _add_property_info_list_callback(CSharpScript *p_script, const String *p_current_class_name, void *p_props, int32_t p_count);
#ifdef TOOLS_ENABLED
static void GD_CLR_STDCALL _add_property_default_values_callback(CSharpScript *p_script, void *p_def_vals, int32_t p_count);
#endif
Fix slow load/save of scenes with many instances of the same script
2021-06-13 13:32:44 +02:00
bool _update_exports(PlaceHolderScriptInstance *p_instance_to_update = nullptr);
Inherited C# scene not inheriting parent's fields When a child scene inherits a parent scene with a C# root node, the parent scene's export variables appear to assume values set in the parent scene, in the child scene's Inspector. However, when the child scene is played, the parent scene's export variables assume default values. When a node is created, it inherits its parent C# script's fields from the map CSharpScriptInstance::script->member_info. However this map was not initialized outside the editor, and this commit ensured it is. This fixes issues #36480 and #37581.
2020-05-10 20:20:11 +02:00
Rename Reference to RefCounted
2021-06-04 18:03:15 +02:00
CSharpInstance *_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_is_ref_counted, Callable::CallError &r_error);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
Variant _new(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
Added mono module
2017-10-02 23:24:00 +02:00
// Do not use unless you know what you are doing
Fix code duplication in CSharpScript Removes code duplication between `CSharpScript::reload()` and `CSharpScript::initialize_for_managed_type()`. Removes a redundant `CSharpScript::update_exports()` call in `CSharpLanguage::reload_assemblies()` as `CSharpScript::reload()` already calls it when appropriate. Fixes missing update of RPC information in `CSharpScript::initialize_for_managed_type()`.
2020-10-12 09:48:29 +02:00
static void update_script_class_info(Ref<CSharpScript> p_script);
Optmized data sent during RPC and RSet calls. - Now is sent the method ID rather the full function name. - The passed IDs (Node and Method) are compressed so to use less possible space. - The variant (INT and BOOL) is now encoded and compressed so to use much less data. - Optimized RPCMode retrieval for GDScript functions. - Added checksum to assert the methods are the same across peers. This work has been kindly sponsored by IMVU.
2020-02-12 11:51:50 +01:00
Added mono module
2017-10-02 23:24:00 +02:00
protected:
static void _bind_methods();
Mono: support custom script templates. Also fixes a bug that prevented methods like `duplicate()` from copying the source code. (Copied from GDScript implementation)
2017-10-30 22:17:20 +01:00
bool _get(const StringName &p_name, Variant &r_ret) const;
bool _set(const StringName &p_name, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_properties) const;
Added mono module
2017-10-02 23:24:00 +02:00
public:
C#: Ensure we only create one CSharpScript per type Previously, for each scripts class instance that was created from code rather than by the engine, we were constructing, configuring and assigning a new CSharpScript. This has changed now and we make sure there's only one CSharpScript associated to each type.
2022-02-27 21:57:36 +01:00
static void reload_registered_script(Ref<CSharpScript> p_script);
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
bool can_instantiate() const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
StringName get_instance_base_type() const override;
ScriptInstance *instance_create(Object *p_this) override;
PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this) override;
bool instance_has(const Object *p_this) const override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool has_source_code() const override;
String get_source_code() const override;
void set_source_code(const String &p_code) override;
Added mono module
2017-10-02 23:24:00 +02:00
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
#ifdef TOOLS_ENABLED
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
virtual Vector<DocData::ClassDoc> get_documentation() const override {
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
// TODO
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
Vector<DocData::ClassDoc> docs;
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
return docs;
}
Add a script method to get its class icon Co-authored-by: Danil Alexeev <danil@alexeev.xyz>
2023-08-24 12:49:20 +02:00
virtual String get_class_icon_path() const override {
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
return type_info.icon_path;
Add a script method to get its class icon Co-authored-by: Danil Alexeev <danil@alexeev.xyz>
2023-08-24 12:49:20 +02:00
}
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
#endif // TOOLS_ENABLED
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Error reload(bool p_keep_state = false) override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool has_script_signal(const StringName &p_signal) const override;
void get_script_signal_list(List<MethodInfo> *r_signals) const override;
Added mono module
2017-10-02 23:24:00 +02:00
C#: Add source generator for signals as events Changed the signal declaration signal to: ``` // The following generates a MySignal event [Signal] public delegate void MySignalEventHandler(int param); ```
2022-07-28 17:41:47 +02:00
Vector<EventSignalInfo> get_script_event_signals() const;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool get_property_default_value(const StringName &p_property, Variant &r_value) const override;
Keep order for C# exported members
2021-10-22 19:25:01 +02:00
void get_script_property_list(List<PropertyInfo> *r_list) const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void update_exports() override;
Added mono module
2017-10-02 23:24:00 +02:00
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
void get_members(HashSet<StringName> *p_members) override;
Mono/C#: Fix values not updated in remote inspector
2020-05-22 00:58:34 +02:00
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
bool is_tool() const override {
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
return type_info.is_tool;
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
}
bool is_valid() const override {
return valid;
}
C#: Abstract script class support
2023-05-23 18:25:34 +02:00
bool is_abstract() const override {
Improve handling of generic C# types - Create CSharpScript for generic C# types. - `ScriptPathAttributeGenerator` registers the path for the generic type definition. - `ScriptManagerBridge` lookup uses the generic type definition that was registered by the generator. - Constructed generic types use a virtual `csharp://` path so they can be registered in the map and loaded as if there was a different file for each constructed type, even though they all share the same real path. - This allows getting the base type for a C# type that derives from a generic type. - Shows base scripts in the _Add Node_ and _Create Resource_ dialogs even when they are generic types. - `get_global_class_name` implementation was moved to C# and now always returns the base type even if the script is not a global class (this behavior matches GDScript). - Create `CSharpScript::TypeInfo` struct to hold all the type information about the C# type that corresponds to the `CSharpScript`, and use it as the parameter in `UpdateScriptClassInfo` to avoid adding more parameters.
2024-02-05 02:49:57 +01:00
return type_info.is_abstract;
C#: Abstract script class support
2023-05-23 18:25:34 +02:00
}
Allow signal connecting even if script is invalid (only when compiled with tools), fixes #17070
2018-11-27 23:55:37 +01:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool inherits_script(const Ref<Script> &p_script) const override;
Add ability to bind typed arrays to script API Note: Only replaced 2 instances to test, Node.get_children and TileMap.get_used_cells Note: Will do a mass replace on later PRs of whathever I can find, but probably need a tool to grep through doc. Warning: Mono will break, needs to be fixed (and so do TypeScript and NativeScript, need to ask respective maintainers)
2020-04-21 00:06:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Ref<Script> get_base_script() const override;
Support script global resource name in EditorFileSystem * Works for binary and text files. * Makes EditorQuickOpen work with custom resources again. * Information is cached and easily accessible. Properly fixes #66179. Supersedes #66215 and supersedes #62417 **WARNING**: This required breaking backwards binary compatibility (.res and .scn files). Files saved after this PR is merged will no longer open in any earlier versions of Godot.
2023-01-19 19:12:25 +01:00
StringName get_global_name() const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
ScriptLanguage *get_language() const override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_script_method_list(List<MethodInfo> *p_list) const override;
bool has_method(const StringName &p_method) const override;
Add methods to get argument count of methods Added to: * `Callable`s * `Object`s * `ClassDB` * `Script(Instance)`s
2024-01-28 15:16:09 +01:00
virtual int get_script_method_argument_count(const StringName &p_method, bool *r_is_valid = nullptr) const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
MethodInfo get_method_info(const StringName &p_method) const override;
C#: make C# static methods accessible.
2023-09-20 16:49:33 +02:00
Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
int get_member_line(const StringName &p_member) const override;
Added mono module
2017-10-02 23:24:00 +02:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
const Variant get_rpc_config() const override;
Optmized data sent during RPC and RSet calls. - Now is sent the method ID rather the full function name. - The passed IDs (Node and Method) are compressed so to use less possible space. - The variant (INT and BOOL) is now encoded and compressed so to use much less data. - Optimized RPCMode retrieval for GDScript functions. - Added checksum to assert the methods are the same across peers. This work has been kindly sponsored by IMVU.
2020-02-12 11:51:50 +01:00
Fix properties being lost when reloading placeholder GDScript instance During reloading in `GDScriptLanguage::reload_all_scripts` a placeholder instance that must remain so is replaced with a new placeholder instance. The state is then restored by calling `ScriptInstance::set` for each property. This does not work if the script is missing the properties due to build/parse failing. The fix for such cases is to call `placeholder_set_fallback` instead of `set` on the script instance. I took this chance to move the `build_failed` flag from `PlaceHolderScriptInstance` to `Script`. That improves the code a lot. I also renamed it to `placeholder_fallback_enabled` which is a much better name (`build_failed` could lead to misunderstandings).
2019-01-10 00:26:00 +01:00
#ifdef TOOLS_ENABLED
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
bool is_placeholder_fallback_enabled() const override {
return placeholder_fallback_enabled;
}
Fix properties being lost when reloading placeholder GDScript instance During reloading in `GDScriptLanguage::reload_all_scripts` a placeholder instance that must remain so is replaced with a new placeholder instance. The state is then restored by calling `ScriptInstance::set` for each property. This does not work if the script is missing the properties due to build/parse failing. The fix for such cases is to call `placeholder_set_fallback` instead of `set` on the script instance. I took this chance to move the `build_failed` flag from `PlaceHolderScriptInstance` to `Script`. That improves the code a lot. I also renamed it to `placeholder_fallback_enabled` which is a much better name (`build_failed` could lead to misunderstandings).
2019-01-10 00:26:00 +01:00
#endif
Added mono module
2017-10-02 23:24:00 +02:00
Error load_source_code(const String &p_path);
CSharpScript();
~CSharpScript();
};
class CSharpInstance : public ScriptInstance {
friend class CSharpScript;
friend class CSharpLanguage;
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
Object *owner = nullptr;
Rename Reference to RefCounted
2021-06-04 18:03:15 +02:00
bool base_ref_counted = false;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
bool ref_dying = false;
bool unsafe_referenced = false;
bool predelete_notified = false;
bool destructing_script_instance = false;
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
Ref<CSharpScript> script;
Mono/C#: Optimize the way we store GC handles for scripts Don't store GC handles for C# script instances and instance bindings as 'Ref<MonoGCHandle>'; store the raw data instead. Initially this was not possible as we needed to store a Variant, but this had not been the case for a looong time yet the stored type was never updated.
2019-12-11 17:08:40 +01:00
MonoGCHandleData gchandle;
Added mono module
2017-10-02 23:24:00 +02:00
C#: Fix disconnecting event signals twice `disconnect_event_signals` can be called twice (when managed instance is disposed and from the ScriptInstance destructor).
2021-03-15 07:08:06 +01:00
List<Callable> connected_event_signals;
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
bool _reference_owner_unsafe();
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
/*
* If true is returned, the caller must memdelete the script instance's owner.
*/
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
bool _unreference_owner_unsafe();
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
/*
C#: Restructure code prior move to .NET Core The main focus here was to remove the majority of code that relied on Mono's embedding APIs, specially the reflection APIs. The embedding APIs we still use are the bare minimum we need for things to work. A lot of code was moved to C#. We no longer deal with any managed objects (`MonoObject*`, and such) in native code, and all marshaling is done in C#. The reason for restructuring the code and move away from embedding APIs is that once we move to .NET Core, we will be limited by the much more minimal .NET hosting. PERFORMANCE REGRESSIONS ----------------------- Some parts of the code were written with little to no concern about performance. This includes code that calls into script methods and accesses script fields, properties and events. The reason for this is that all of that will be moved to source generators, so any work prior to that would be a waste of time. DISABLED FEATURES ----------------- Some code was removed as it no longer makes sense (or won't make sense in the future). Other parts were commented out with `#if 0`s and TODO warnings because it doesn't make much sense to work on them yet as those parts will change heavily when we switch to .NET Core but also when we start introducing source generators. As such, the following features were disabled temporarily: - Assembly-reloading (will be done with ALCs in .NET Core). - Properties/fields exports and script method listing (will be handled by source generators in the future). - Exception logging in the editor and stack info for errors. - Exporting games. - Building of C# projects. We no longer copy the Godot API assemblies to the project directory, so MSBuild won't be able to find them. The idea is to turn them into NuGet packages in the future, which could also be obtained from local NuGet sources during development.
2021-09-12 20:21:15 +02:00
* If false is returned, the caller must destroy the script instance by removing it from its owner.
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
*/
C#: Restructure code prior move to .NET Core The main focus here was to remove the majority of code that relied on Mono's embedding APIs, specially the reflection APIs. The embedding APIs we still use are the bare minimum we need for things to work. A lot of code was moved to C#. We no longer deal with any managed objects (`MonoObject*`, and such) in native code, and all marshaling is done in C#. The reason for restructuring the code and move away from embedding APIs is that once we move to .NET Core, we will be limited by the much more minimal .NET hosting. PERFORMANCE REGRESSIONS ----------------------- Some parts of the code were written with little to no concern about performance. This includes code that calls into script methods and accesses script fields, properties and events. The reason for this is that all of that will be moved to source generators, so any work prior to that would be a waste of time. DISABLED FEATURES ----------------- Some code was removed as it no longer makes sense (or won't make sense in the future). Other parts were commented out with `#if 0`s and TODO warnings because it doesn't make much sense to work on them yet as those parts will change heavily when we switch to .NET Core but also when we start introducing source generators. As such, the following features were disabled temporarily: - Assembly-reloading (will be done with ALCs in .NET Core). - Properties/fields exports and script method listing (will be handled by source generators in the future). - Exception logging in the editor and stack info for errors. - Exporting games. - Building of C# projects. We no longer copy the Godot API assemblies to the project directory, so MSBuild won't be able to find them. The idea is to turn them into NuGet packages in the future, which could also be obtained from local NuGet sources during development.
2021-09-12 20:21:15 +02:00
bool _internal_new_managed();
Added mono module
2017-10-02 23:24:00 +02:00
// Do not use unless you know what you are doing
Mono/C#: Optimize the way we store GC handles for scripts Don't store GC handles for C# script instances and instance bindings as 'Ref<MonoGCHandle>'; store the raw data instead. Initially this was not possible as we needed to store a Variant, but this had not been the case for a looong time yet the stored type was never updated.
2019-12-11 17:08:40 +01:00
static CSharpInstance *create_for_managed_type(Object *p_owner, CSharpScript *p_script, const MonoGCHandleData &p_gchandle);
Added mono module
2017-10-02 23:24:00 +02:00
public:
Fix crash due to ~CSharpInstance() being called on freed instance This would be the case when calling SetScript on an object with a C# script.
2018-12-01 02:23:55 +01:00
_FORCE_INLINE_ bool is_destructing_script_instance() { return destructing_script_instance; }
C#: Restructure code prior move to .NET Core The main focus here was to remove the majority of code that relied on Mono's embedding APIs, specially the reflection APIs. The embedding APIs we still use are the bare minimum we need for things to work. A lot of code was moved to C#. We no longer deal with any managed objects (`MonoObject*`, and such) in native code, and all marshaling is done in C#. The reason for restructuring the code and move away from embedding APIs is that once we move to .NET Core, we will be limited by the much more minimal .NET hosting. PERFORMANCE REGRESSIONS ----------------------- Some parts of the code were written with little to no concern about performance. This includes code that calls into script methods and accesses script fields, properties and events. The reason for this is that all of that will be moved to source generators, so any work prior to that would be a waste of time. DISABLED FEATURES ----------------- Some code was removed as it no longer makes sense (or won't make sense in the future). Other parts were commented out with `#if 0`s and TODO warnings because it doesn't make much sense to work on them yet as those parts will change heavily when we switch to .NET Core but also when we start introducing source generators. As such, the following features were disabled temporarily: - Assembly-reloading (will be done with ALCs in .NET Core). - Properties/fields exports and script method listing (will be handled by source generators in the future). - Exception logging in the editor and stack info for errors. - Exporting games. - Building of C# projects. We no longer copy the Godot API assemblies to the project directory, so MSBuild won't be able to find them. The idea is to turn them into NuGet packages in the future, which could also be obtained from local NuGet sources during development.
2021-09-12 20:21:15 +02:00
_FORCE_INLINE_ GCHandleIntPtr get_gchandle_intptr() { return gchandle.get_intptr(); }
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Object *get_owner() override;
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool set(const StringName &p_name, const Variant &p_value) override;
bool get(const StringName &p_name, Variant &r_ret) const override;
void get_property_list(List<PropertyInfo> *p_properties) const override;
Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid) const override;
Expose _validate_property() for scripting
2023-04-07 14:01:57 +02:00
virtual void validate_property(PropertyInfo &p_property) const override;
Added mono module
2017-10-02 23:24:00 +02:00
Make `property_*_revert` methods multilevel and expose them for scripting
2022-08-12 20:43:14 +02:00
bool property_can_revert(const StringName &p_name) const override;
bool property_get_revert(const StringName &p_name, Variant &r_ret) const override;
Improve C# method listing - implement CSharpInstance::get_method_list - loop through parent classes in CSharpInstance::get_method_list and CSharpScript::get_script_method_list (#46408)
2021-09-12 19:53:34 +02:00
void get_method_list(List<MethodInfo> *p_list) const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool has_method(const StringName &p_method) const override;
Add methods to get argument count of methods Added to: * `Callable`s * `Object`s * `ClassDB` * `Script(Instance)`s
2024-01-28 15:16:09 +01:00
virtual int get_method_argument_count(const StringName &p_method, bool *r_is_valid = nullptr) const override;
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
Added mono module
2017-10-02 23:24:00 +02:00
C#: Add source generator for properties and exports default values The editor no longer needs to create temporary instances to get the default values. The initializer values of the exported properties are still evaluated at runtime. For example, in the following example, `GetInitialValue()` will be called when first looks for default values: ``` [Export] int MyValue = GetInitialValue(); ``` Exporting fields with a non-supported type now results in a compiler error rather than a runtime error when the script is used.
2022-02-27 21:57:30 +01:00
void mono_object_disposed(GCHandleIntPtr p_gchandle_to_free);
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
/*
C#: Fix custom event signals crash on hot-reload Cleanup and re-initialization of event signals before and after hot-reload should be working correctly now.
2020-10-26 06:59:08 +01:00
* If 'r_delete_owner' is set to true, the caller must memdelete the script instance's owner. Otherwise, if
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
* 'r_remove_script_instance' is set to true, the caller must destroy the script instance by removing it from its owner.
*/
C#: Add source generator for properties and exports default values The editor no longer needs to create temporary instances to get the default values. The initializer values of the exported properties are still evaluated at runtime. For example, in the following example, `GetInitialValue()` will be called when first looks for default values: ``` [Export] int MyValue = GetInitialValue(); ``` Exporting fields with a non-supported type now results in a compiler error rather than a runtime error when the script is used.
2022-02-27 21:57:30 +01:00
void mono_object_disposed_baseref(GCHandleIntPtr p_gchandle_to_free, bool p_is_finalizer, bool &r_delete_owner, bool &r_remove_script_instance);
Added mono module
2017-10-02 23:24:00 +02:00
C#: Add source generator for signals as events Changed the signal declaration signal to: ``` // The following generates a MySignal event [Signal] public delegate void MySignalEventHandler(int param); ```
2022-07-28 17:41:47 +02:00
void connect_event_signals();
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
void disconnect_event_signals();
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void refcount_incremented() override;
bool refcount_decremented() override;
Added mono module
2017-10-02 23:24:00 +02:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
const Variant get_rpc_config() const override;
Added mono module
2017-10-02 23:24:00 +02:00
Fix Object::notification order Previously the `p_reversed` parameter didn't influence the order in a correct way. Also script overridden _notification functions were not called in the correct order. To fix this some `notification` functions had to add a `p_reversed` parameter. This made it necessary to adjust cpp-bindings. Co-authored-by: David Snopek <dsnopek@gmail.com>
2023-06-24 03:07:22 +02:00
void notification(int p_notification, bool p_reversed = false) override;
void _call_notification(int p_notification, bool p_reversed = false);
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
String to_string(bool *r_valid) override;
C#: Implement ScriptInstance::to_string Create a blacklist of methods that must not be generated. Includes: "to_string", "_to_string" and "_init".
2019-05-24 00:40:16 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Ref<Script> get_script() const override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
ScriptLanguage *get_language() override;
Added mono module
2017-10-02 23:24:00 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
CSharpInstance(const Ref<CSharpScript> &p_script);
Added mono module
2017-10-02 23:24:00 +02:00
~CSharpInstance();
};
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
struct CSharpScriptBinding {
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 17:01:17 +02:00
bool inited = false;
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
StringName type_name;
Mono/C#: Optimize the way we store GC handles for scripts Don't store GC handles for C# script instances and instance bindings as 'Ref<MonoGCHandle>'; store the raw data instead. Initially this was not possible as we needed to store a Variant, but this had not been the case for a looong time yet the stored type was never updated.
2019-12-11 17:08:40 +01:00
MonoGCHandleData gchandle;
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 17:01:17 +02:00
Object *owner = nullptr;
Mono/C#: Optimize the way we store GC handles for scripts Don't store GC handles for C# script instances and instance bindings as 'Ref<MonoGCHandle>'; store the raw data instead. Initially this was not possible as we needed to store a Variant, but this had not been the case for a looong time yet the stored type was never updated.
2019-12-11 17:08:40 +01:00
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 17:01:17 +02:00
CSharpScriptBinding() {}
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
};
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
class ManagedCallableMiddleman : public Object {
GDCLASS(ManagedCallableMiddleman, Object);
};
Added mono module
2017-10-02 23:24:00 +02:00
class CSharpLanguage : public ScriptLanguage {
friend class CSharpScript;
friend class CSharpInstance;
static CSharpLanguage *singleton;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
bool finalizing = false;
bool finalized = false;
Mono: Script lifetime fixes - alloc_language_binding: Use strong GC handle as well for references. Fixes #15138 - Set the native instance field of Godot.Object to IntPtr.Zero when it's freed. - Create weak handles without tracking resurrection (that was causing trouble). This means we have to call notification predelete before queueing a native Object for deletion, and use the MonoObject* passed by the finalizer because the weak GC handle target will return NULL at this point.
2017-12-31 22:37:57 +01:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
GDMono *gdmono = nullptr;
Added mono module
2017-10-02 23:24:00 +02:00
SelfList<CSharpScript>::List script_list;
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
Mutex script_instances_mutex;
Mutex script_gchandle_release_mutex;
Mutex language_bind_mutex;
Added mono module
2017-10-02 23:24:00 +02:00
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
RBMap<Object *, CSharpScriptBinding> script_bindings;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Add error checks to detect possible Reference leaks
2020-01-13 21:00:07 +01:00
#ifdef DEBUG_ENABLED
Mono/C#: Lighten up unsafe reference checks Because of the weird case with multi-threading and ResourceLoader, it can be the case that a resource is GCed while being referenced again in the main thread. In such cases, a new unsafe reference is created before the finalizer thread removes the previous one.
2020-01-23 21:23:32 +01:00
// List of unsafe object references
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<ObjectID, int> unsafe_object_references;
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
Mutex unsafe_object_references_lock;
Mono/C#: Add error checks to detect possible Reference leaks
2020-01-13 21:00:07 +01:00
#endif
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
ManagedCallableMiddleman *managed_callable_middleman = memnew(ManagedCallableMiddleman);
int lang_idx = -1;
Added mono module
2017-10-02 23:24:00 +02:00
Mono: Partially implement some Godot debug api functions Debug breaks sent with debug_break and debug_break_parse should display correctly in the Godot debugger now.
2019-03-07 20:47:13 +01:00
// For debug_break and debug_break_parse
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
int _debug_parse_err_line = -1;
Mono: Partially implement some Godot debug api functions Debug breaks sent with debug_break and debug_break_parse should display correctly in the Godot debugger now.
2019-03-07 20:47:13 +01:00
String _debug_parse_err_file;
String _debug_error;
Mono: Fix crash when re-using script binding after domain reloading
2019-03-07 19:55:40 +01:00
friend class GDMono;
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
#ifdef TOOLS_ENABLED
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
EditorPlugin *godotsharp_editor = nullptr;
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
static void _editor_init_callback();
#endif
Fix C# native instance bindings after recent re-write This was needed after: 44691448911f1d29d4d79dbdd5553734761e57c4
2021-08-16 17:16:36 +02:00
static void *_instance_binding_create_callback(void *p_token, void *p_instance);
static void _instance_binding_free_callback(void *p_token, void *p_instance, void *p_binding);
Rename all gdnative occurences to gdextension Non-exhaustive list of case-sensitive renames: GDExtension -> GDNative GDNATIVE -> GDEXTENSION gdextension -> gdnative ExtensionExtension ->Extension (for where there was GDNativeExtension) EXTENSION_EXTENSION ->EXTENSION (for where there was GDNATIVE_EXTENSION) gdnlib -> gdextension gdn_interface -> gde_interface gdni -> gde_interface
2022-12-07 12:11:28 +01:00
static GDExtensionBool _instance_binding_reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference);
Fix C# native instance bindings after recent re-write This was needed after: 44691448911f1d29d4d79dbdd5553734761e57c4
2021-08-16 17:16:36 +02:00
Rename all gdnative occurences to gdextension Non-exhaustive list of case-sensitive renames: GDExtension -> GDNative GDNATIVE -> GDEXTENSION gdextension -> gdnative ExtensionExtension ->Extension (for where there was GDNativeExtension) EXTENSION_EXTENSION ->EXTENSION (for where there was GDNATIVE_EXTENSION) gdnlib -> gdextension gdn_interface -> gde_interface gdni -> gde_interface
2022-12-07 12:11:28 +01:00
static GDExtensionInstanceBindingCallbacks _instance_binding_callbacks;
Fix C# native instance bindings after recent re-write This was needed after: 44691448911f1d29d4d79dbdd5553734761e57c4
2021-08-16 17:16:36 +02:00
Added mono module
2017-10-02 23:24:00 +02:00
public:
Fix C# native instance bindings after recent re-write This was needed after: 44691448911f1d29d4d79dbdd5553734761e57c4
2021-08-16 17:16:36 +02:00
static void *get_instance_binding(Object *p_object);
static void *get_existing_instance_binding(Object *p_object);
static void set_instance_binding(Object *p_object, void *p_binding);
static bool has_instance_binding(Object *p_object);
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
const Mutex &get_language_bind_mutex() {
return language_bind_mutex;
}
const Mutex &get_script_instances_mutex() {
return script_instances_mutex;
}
Use script instance binding for objects constructed from C# Only possible if the object class is a "native type". If the object class is a user class (that derives a "native type") then a script is needed. Since CSharpLanguage does cleanup of script instance bindings when finished, cases like #25621 will no longer cause problems. Fixed ~Object() trying to free script instance bindings after the language has already been removed, which would result in a NULL dereference.
2019-02-04 20:39:02 +01:00
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
_FORCE_INLINE_ int get_language_index() {
return lang_idx;
}
Added mono module
2017-10-02 23:24:00 +02:00
void set_language_index(int p_idx);
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
_FORCE_INLINE_ static CSharpLanguage *get_singleton() {
return singleton;
}
Added mono module
2017-10-02 23:24:00 +02:00
Mono: Fix build errors with tools=no
2019-07-08 15:22:51 +02:00
#ifdef TOOLS_ENABLED
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
_FORCE_INLINE_ EditorPlugin *get_godotsharp_editor() const {
return godotsharp_editor;
}
Mono: Fix build errors with tools=no
2019-07-08 15:22:51 +02:00
#endif
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
Mono/C#: Optimize the way we store GC handles for scripts Don't store GC handles for C# script instances and instance bindings as 'Ref<MonoGCHandle>'; store the raw data instead. Initially this was not possible as we needed to store a Variant, but this had not been the case for a looong time yet the stored type was never updated.
2019-12-11 17:08:40 +01:00
static void release_script_gchandle(MonoGCHandleData &p_gchandle);
C#: Add source generator for properties and exports default values The editor no longer needs to create temporary instances to get the default values. The initializer values of the exported properties are still evaluated at runtime. For example, in the following example, `GetInitialValue()` will be called when first looks for default values: ``` [Export] int MyValue = GetInitialValue(); ``` Exporting fields with a non-supported type now results in a compiler error rather than a runtime error when the script is used.
2022-02-27 21:57:30 +01:00
static void release_script_gchandle_thread_safe(GCHandleIntPtr p_gchandle_to_free, MonoGCHandleData &r_gchandle);
static void release_binding_gchandle_thread_safe(GCHandleIntPtr p_gchandle_to_free, CSharpScriptBinding &r_script_binding);
Fix/workaround for issue #21667 When a Reference managed instance is garbage collected and its finalizer is called, it could happen that the native instance is referenced once again before the finalizer can unreference and memdelete it. The workaround is to create a new managed instance when this happens (at least for now).
2018-09-12 02:41:54 +02:00
Added mono module
2017-10-02 23:24:00 +02:00
bool debug_break(const String &p_error, bool p_allow_continue = true);
bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
Mono: Fix hot reload build errors and cleanup
2019-01-22 18:33:36 +01:00
#ifdef GD_MONO_HOT_RELOAD
C#: Improve tool script support and fix reloading issues
2018-11-30 20:43:06 +01:00
bool is_assembly_reloading_needed();
void reload_assemblies(bool p_soft_reload);
Added mono module
2017-10-02 23:24:00 +02:00
#endif
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
_FORCE_INLINE_ ManagedCallableMiddleman *get_managed_callable_middleman() const {
return managed_callable_middleman;
}
Parse C# script namespace and class - Added a very simple parser that can extract the namespace and class name of a C# script.
2018-10-22 19:43:19 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
String get_name() const override;
Added mono module
2017-10-02 23:24:00 +02:00
/* LANGUAGE FUNCTIONS */
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
String get_type() const override;
String get_extension() const override;
void init() override;
void finish() override;
void finalize();
Added mono module
2017-10-02 23:24:00 +02:00
/* EDITOR FUNCTIONS */
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_reserved_words(List<String> *p_words) const override;
Add const lvalue ref to core/* container parameters
2024-01-09 02:36:19 +01:00
bool is_control_flow_keyword(const String &p_keyword) const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_comment_delimiters(List<String> *p_delimiters) const override;
Highlight doc comments in a different color
2023-02-05 10:01:01 +01:00
void get_doc_comment_delimiters(List<String> *p_delimiters) const override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_string_delimiters(List<String> *p_delimiters) const override;
bool is_using_templates() override;
Improve editor template workflow Co-Authored-By: jmb462 <jmb462@gmail.com>
2021-10-11 11:30:59 +02:00
virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
Add const lvalue ref to container parameters
2021-08-01 21:47:20 +02:00
virtual Vector<ScriptTemplate> get_built_in_templates(const StringName &p_object) override;
Added support for scripts reporting multiple errors to ScriptTextEditor Scripts can now report multiple errors to the scripting editors in the engine. UI elements were added to support multiple errors.
2021-05-18 05:09:19 +02:00
/* TODO */ bool validate(const String &p_script, const String &p_path, List<String> *r_functions,
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override {
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
return true;
}
String validate_path(const String &p_path) const override;
Script *create_script() const override;
Editor: Remove unused Class Name field from Create Script dialog
2023-09-12 10:52:43 +02:00
#ifndef DISABLE_DEPRECATED
virtual bool has_named_classes() const override { return false; }
#endif
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
bool supports_builtin_mode() const override;
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
/* TODO? */ int find_function(const String &p_function, const String &p_code) const override {
return -1;
}
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override;
Disable signal callback generation in C#
2024-02-04 19:08:41 +01:00
virtual bool can_make_function() const override { return false; }
Mono: support custom script templates. Also fixes a bug that prevented methods like `duplicate()` from copying the source code. (Copied from GDScript implementation)
2017-10-30 22:17:20 +01:00
virtual String _get_indentation() const;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
/* TODO? */ void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override {}
/* TODO */ void add_global_constant(const StringName &p_variable, const Variant &p_value) override {}
Allow configuring the script filename casing rule Defaults to "Auto", which detects the casing based on the preference of the currently selected language (C# for example prefers PascalCase whereas GDScript prefers snake_case).
2023-06-11 18:23:48 +02:00
virtual ScriptNameCasing preferred_file_name_casing() const override;
Added mono module
2017-10-02 23:24:00 +02:00
C#: Add global class support Co-authored-by: willnationsdev <willnationsdev@gmail.com>
2023-02-02 00:54:16 +01:00
/* SCRIPT GLOBAL CLASS FUNCTIONS */
virtual bool handles_global_class_type(const String &p_type) const override;
virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const override;
Added mono module
2017-10-02 23:24:00 +02:00
/* DEBUGGER FUNCTIONS */
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
String debug_get_error() const override;
int debug_get_stack_level_count() const override;
int debug_get_stack_level_line(int p_level) const override;
String debug_get_stack_level_function(int p_level) const override;
String debug_get_stack_level_source(int p_level) const override;
/* TODO */ void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
/* TODO */ void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
/* TODO */ void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
/* TODO */ String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) override {
return "";
}
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Vector<StackInfo> debug_get_current_stack_info() override;
Added mono module
2017-10-02 23:24:00 +02:00
/* PROFILING FUNCTIONS */
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
/* TODO */ void profiling_start() override {}
/* TODO */ void profiling_stop() override {}
Fix missing time for some script functions in profiler Fixes the issue by adding a mechanism by which the functions that were previously disappearing can be profiled too. This is optional with an editor setting, since collecting more information naturally slows the engine further while profiling. Fixes #23715, #40251, #29049
2023-03-05 13:37:11 +01:00
/* TODO */ void profiling_set_save_native_calls(bool p_enable) override {}
C#: Re-implement assembly reloading with ALCs
2022-05-28 04:56:46 +02:00
/* TODO */ int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override {
return 0;
}
/* TODO */ int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override {
return 0;
}
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void frame() override;
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
/* TODO? */ void get_public_functions(List<MethodInfo> *p_functions) const override {}
/* TODO? */ void get_public_constants(List<Pair<String, Variant>> *p_constants) const override {}
Add support for documenting built-in annotations
2022-07-04 17:56:34 +02:00
/* TODO? */ void get_public_annotations(List<MethodInfo> *p_annotations) const override {}
Added mono module
2017-10-02 23:24:00 +02:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void reload_all_scripts() override;
Hot-reload only changed scripts
2023-12-30 08:06:54 +01:00
void reload_scripts(const Array &p_scripts, bool p_soft_reload) override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) override;
Added mono module
2017-10-02 23:24:00 +02:00
/* LOADER FUNCTIONS */
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_recognized_extensions(List<String> *p_extensions) const override;
Added mono module
2017-10-02 23:24:00 +02:00
#ifdef TOOLS_ENABLED
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) override;
bool overrides_external_editor() override;
Added mono module
2017-10-02 23:24:00 +02:00
#endif
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
RBMap<Object *, CSharpScriptBinding>::Element *insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding);
Mono: Lifetime fixes for CSharpInstance and instance binding data Avoid CSharpInstance from accessing its state after self destructing (by deleting the Reference owner). It's now safe to replace the script instance without leaking or crashing. Also fixed godot_icall_Object_weakref return reference being freed before returning.
2019-02-03 06:35:22 +01:00
bool setup_csharp_script_binding(CSharpScriptBinding &r_script_binding, Object *p_object);
C#: Restructure code prior move to .NET Core The main focus here was to remove the majority of code that relied on Mono's embedding APIs, specially the reflection APIs. The embedding APIs we still use are the bare minimum we need for things to work. A lot of code was moved to C#. We no longer deal with any managed objects (`MonoObject*`, and such) in native code, and all marshaling is done in C#. The reason for restructuring the code and move away from embedding APIs is that once we move to .NET Core, we will be limited by the much more minimal .NET hosting. PERFORMANCE REGRESSIONS ----------------------- Some parts of the code were written with little to no concern about performance. This includes code that calls into script methods and accesses script fields, properties and events. The reason for this is that all of that will be moved to source generators, so any work prior to that would be a waste of time. DISABLED FEATURES ----------------- Some code was removed as it no longer makes sense (or won't make sense in the future). Other parts were commented out with `#if 0`s and TODO warnings because it doesn't make much sense to work on them yet as those parts will change heavily when we switch to .NET Core but also when we start introducing source generators. As such, the following features were disabled temporarily: - Assembly-reloading (will be done with ALCs in .NET Core). - Properties/fields exports and script method listing (will be handled by source generators in the future). - Exception logging in the editor and stack info for errors. - Exporting games. - Building of C# projects. We no longer copy the Godot API assemblies to the project directory, so MSBuild won't be able to find them. The idea is to turn them into NuGet packages in the future, which could also be obtained from local NuGet sources during development.
2021-09-12 20:21:15 +02:00
static void tie_native_managed_to_unmanaged(GCHandleIntPtr p_gchandle_intptr, Object *p_unmanaged, const StringName *p_native_name, bool p_ref_counted);
C#: Ensure we only create one CSharpScript per type Previously, for each scripts class instance that was created from code rather than by the engine, we were constructing, configuring and assigning a new CSharpScript. This has changed now and we make sure there's only one CSharpScript associated to each type.
2022-02-27 21:57:36 +01:00
static void tie_user_managed_to_unmanaged(GCHandleIntPtr p_gchandle_intptr, Object *p_unmanaged, Ref<CSharpScript> *p_script, bool p_ref_counted);
C#: Restructure code prior move to .NET Core The main focus here was to remove the majority of code that relied on Mono's embedding APIs, specially the reflection APIs. The embedding APIs we still use are the bare minimum we need for things to work. A lot of code was moved to C#. We no longer deal with any managed objects (`MonoObject*`, and such) in native code, and all marshaling is done in C#. The reason for restructuring the code and move away from embedding APIs is that once we move to .NET Core, we will be limited by the much more minimal .NET hosting. PERFORMANCE REGRESSIONS ----------------------- Some parts of the code were written with little to no concern about performance. This includes code that calls into script methods and accesses script fields, properties and events. The reason for this is that all of that will be moved to source generators, so any work prior to that would be a waste of time. DISABLED FEATURES ----------------- Some code was removed as it no longer makes sense (or won't make sense in the future). Other parts were commented out with `#if 0`s and TODO warnings because it doesn't make much sense to work on them yet as those parts will change heavily when we switch to .NET Core but also when we start introducing source generators. As such, the following features were disabled temporarily: - Assembly-reloading (will be done with ALCs in .NET Core). - Properties/fields exports and script method listing (will be handled by source generators in the future). - Exception logging in the editor and stack info for errors. - Exporting games. - Building of C# projects. We no longer copy the Godot API assemblies to the project directory, so MSBuild won't be able to find them. The idea is to turn them into NuGet packages in the future, which could also be obtained from local NuGet sources during development.
2021-09-12 20:21:15 +02:00
static void tie_managed_to_unmanaged_with_pre_setup(GCHandleIntPtr p_gchandle_intptr, Object *p_unmanaged);
Mono/C#: Add error checks to detect possible Reference leaks
2020-01-13 21:00:07 +01:00
void post_unsafe_reference(Object *p_obj);
void pre_unsafe_unreference(Object *p_obj);
Added mono module
2017-10-02 23:24:00 +02:00
CSharpLanguage();
~CSharpLanguage();
};
class ResourceFormatLoaderCSharpScript : public ResourceFormatLoader {
public:
Remove `RES` and `REF` typedefs in favor of spelled out `Ref<>` These typedefs don't save much typing compared to the full `Ref<Resource>` and `Ref<RefCounted>`, yet they sometimes introduce confusion among new contributors.
2022-05-03 01:43:50 +02:00
Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-05 19:19:36 +02:00
void get_recognized_extensions(List<String> *p_extensions) const override;
bool handles_type(const String &p_type) const override;
String get_resource_type(const String &p_path) const override;
Added mono module
2017-10-02 23:24:00 +02:00
};
class ResourceFormatSaverCSharpScript : public ResourceFormatSaver {
public:
Swap arguments of ResourceSaver.save()
2022-06-03 01:33:42 +02:00
Error save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags = 0) override;
Remove `RES` and `REF` typedefs in favor of spelled out `Ref<>` These typedefs don't save much typing compared to the full `Ref<Resource>` and `Ref<RefCounted>`, yet they sometimes introduce confusion among new contributors.
2022-05-03 01:43:50 +02:00
void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
bool recognize(const Ref<Resource> &p_resource) const override;
Added mono module
2017-10-02 23:24:00 +02:00
};
#endif // CSHARP_SCRIPT_H
Reference in a new issue Copy permalink