Relintai/mono
1
0
Fork 0
mirror of https://github.com/Relintai/mono.git synced 2024-11-08 10:12:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix build.

Browse Source
This commit is contained in:
Relintai 2023-05-23 20:55:56 +02:00
parent e7b9b694e8
commit e680d35108
61 changed files with 399 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
class_db_api_json.cpp
View File

@ -34,7 +34,7 @@
#include "core/io/json.h" #include "core/io/json.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "core/version.h" #include "core/version.h"
void class_db_api_to_json(const String &p_output_file, ClassDB::APIType p_api) { void class_db_api_to_json(const String &p_output_file, ClassDB::APIType p_api) {

4
class_db_api_json.h
View File

@ -33,11 +33,11 @@
// 'core/method_bind.h' defines DEBUG_METHODS_ENABLED, but it looks like we // 'core/method_bind.h' defines DEBUG_METHODS_ENABLED, but it looks like we
// cannot include it here. That's why we include it through 'core/class_db.h'. // cannot include it here. That's why we include it through 'core/class_db.h'.
#include "core/class_db.h" #include "core/object/class_db.h"
#ifdef DEBUG_METHODS_ENABLED #ifdef DEBUG_METHODS_ENABLED
#include "core/ustring.h" #include "core/string/ustring.h"
void class_db_api_to_json(const String &p_output_file, ClassDB::APIType p_api); void class_db_api_to_json(const String &p_output_file, ClassDB::APIType p_api);

63
csharp_script.cpp
View File

@ -36,7 +36,7 @@
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/os/thread.h" #include "core/os/thread.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "core/os/keyboard.h" #include "core/os/keyboard.h"
@ -45,6 +45,7 @@
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_settings.h" #include "editor/editor_settings.h"
#include "editor/node_dock.h" #include "editor/node_dock.h"
#include "editor/editor_inspector.h"
#endif #endif
#ifdef DEBUG_METHODS_ENABLED #ifdef DEBUG_METHODS_ENABLED
@ -136,7 +137,7 @@ void CSharpLanguage::finish() {
finalizing = true; finalizing = true;
// Make sure all script binding gchandles are released before finalizing GDMono // Make sure all script binding gchandles are released before finalizing GDMono
for (Map<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) { for (RBMap<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) {
CSharpScriptBinding &script_binding = E->value(); CSharpScriptBinding &script_binding = E->value();
if (script_binding.gchandle.is_valid()) { if (script_binding.gchandle.is_valid()) {
@ -154,7 +155,7 @@ void CSharpLanguage::finish() {
script_bindings.clear(); script_bindings.clear();
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
for (Map<ObjectID, int>::Element *E = unsafe_object_references.front(); E; E = E->next()) { for (RBMap<ObjectID, int>::Element *E = unsafe_object_references.front(); E; E = E->next()) {
const ObjectID &id = E->key(); const ObjectID &id = E->key();
Object *obj = ObjectDB::get_instance(id); Object *obj = ObjectDB::get_instance(id);
@ -463,13 +464,13 @@ static String variant_type_to_managed_name(const String &p_var_type_name) {
Variant::VECTOR3, Variant::VECTOR3,
Variant::TRANSFORM2D, Variant::TRANSFORM2D,
Variant::PLANE, Variant::PLANE,
Variant::QUAT, Variant::QUATERNION,
Variant::AABB, Variant::AABB,
Variant::BASIS, Variant::BASIS,
Variant::TRANSFORM, Variant::TRANSFORM,
Variant::COLOR, Variant::COLOR,
Variant::NODE_PATH, Variant::NODE_PATH,
Variant::_RID Variant::RID
}; };
for (unsigned int i = 0; i < sizeof(var_types) / sizeof(Variant::Type); i++) { for (unsigned int i = 0; i < sizeof(var_types) / sizeof(Variant::Type); i++) {
@ -643,7 +644,7 @@ void CSharpLanguage::pre_unsafe_unreference(Object *p_obj) {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
MutexLock lock(unsafe_object_references_lock); MutexLock lock(unsafe_object_references_lock);
ObjectID id = p_obj->get_instance_id(); ObjectID id = p_obj->get_instance_id();
Map<ObjectID, int>::Element *elem = unsafe_object_references.find(id); RBMap<ObjectID, int>::Element *elem = unsafe_object_references.find(id);
ERR_FAIL_NULL(elem); ERR_FAIL_NULL(elem);
if (--elem->value() == 0) if (--elem->value() == 0)
unsafe_object_references.erase(elem); unsafe_object_references.erase(elem);
@ -776,7 +777,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
// We need to keep reference instances alive during reloading // We need to keep reference instances alive during reloading
List<Ref<Reference>> ref_instances; List<Ref<Reference>> ref_instances;
for (Map<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) { for (RBMap<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) {
CSharpScriptBinding &script_binding = E->value(); CSharpScriptBinding &script_binding = E->value();
Reference *ref = Object::cast_to<Reference>(script_binding.owner); Reference *ref = Object::cast_to<Reference>(script_binding.owner);
if (ref) { if (ref) {
@ -807,7 +808,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
// Script::instances are deleted during managed object disposal, which happens on domain finalize. // Script::instances are deleted during managed object disposal, which happens on domain finalize.
// Only placeholders are kept. Therefore we need to keep a copy before that happens. // Only placeholders are kept. Therefore we need to keep a copy before that happens.
for (Set<Object *>::Element *F = script->instances.front(); F; F = F->next()) { for (RBSet<Object *>::Element *F = script->instances.front(); F; F = F->next()) {
Object *obj = F->get(); Object *obj = F->get();
script->pending_reload_instances.insert(obj->get_instance_id()); script->pending_reload_instances.insert(obj->get_instance_id());
@ -818,7 +819,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
} }
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
for (Set<PlaceHolderScriptInstance *>::Element *F = script->placeholders.front(); F; F = F->next()) { for (RBSet<PlaceHolderScriptInstance *>::Element *F = script->placeholders.front(); F; F = F->next()) {
Object *obj = F->get()->get_owner(); Object *obj = F->get()->get_owner();
script->pending_reload_instances.insert(obj->get_instance_id()); script->pending_reload_instances.insert(obj->get_instance_id());
@ -830,9 +831,9 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
#endif #endif
// Save state and remove script from instances // Save state and remove script from instances
Map<ObjectID, CSharpScript::StateBackup> &owners_map = script->pending_reload_state; RBMap<ObjectID, CSharpScript::StateBackup> &owners_map = script->pending_reload_state;
for (Set<Object *>::Element *F = script->instances.front(); F; F = F->next()) { for (RBSet<Object *>::Element *F = script->instances.front(); F; F = F->next()) {
Object *obj = F->get(); Object *obj = F->get();
ERR_CONTINUE(!obj->get_script_instance()); ERR_CONTINUE(!obj->get_script_instance());
@ -872,7 +873,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
for (List<Ref<CSharpScript>>::Element *E = to_reload.front(); E; E = E->next()) { for (List<Ref<CSharpScript>>::Element *E = to_reload.front(); E; E = E->next()) {
Ref<CSharpScript> scr = E->get(); Ref<CSharpScript> scr = E->get();
for (const Map<ObjectID, CSharpScript::StateBackup>::Element *F = scr->pending_reload_state.front(); F; F = F->next()) { for (const RBMap<ObjectID, CSharpScript::StateBackup>::Element *F = scr->pending_reload_state.front(); F; F = F->next()) {
Object *obj = ObjectDB::get_instance(F->key()); Object *obj = ObjectDB::get_instance(F->key());
if (!obj) if (!obj)
@ -963,7 +964,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
String native_name = NATIVE_GDMONOCLASS_NAME(script->native); String native_name = NATIVE_GDMONOCLASS_NAME(script->native);
{ {
for (Set<ObjectID>::Element *F = script->pending_reload_instances.front(); F; F = F->next()) { for (RBSet<ObjectID>::Element *F = script->pending_reload_instances.front(); F; F = F->next()) {
ObjectID obj_id = F->get(); ObjectID obj_id = F->get();
Object *obj = ObjectDB::get_instance(obj_id); Object *obj = ObjectDB::get_instance(obj_id);
@ -1018,7 +1019,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
for (List<Ref<CSharpScript>>::Element *E = to_reload_state.front(); E; E = E->next()) { for (List<Ref<CSharpScript>>::Element *E = to_reload_state.front(); E; E = E->next()) {
Ref<CSharpScript> script = E->get(); Ref<CSharpScript> script = E->get();
for (Set<ObjectID>::Element *F = script->pending_reload_instances.front(); F; F = F->next()) { for (RBSet<ObjectID>::Element *F = script->pending_reload_instances.front(); F; F = F->next()) {
ObjectID obj_id = F->get(); ObjectID obj_id = F->get();
Object *obj = ObjectDB::get_instance(obj_id); Object *obj = ObjectDB::get_instance(obj_id);
@ -1156,7 +1157,7 @@ bool CSharpLanguage::debug_break(const String &p_error, bool p_allow_continue) {
} }
void CSharpLanguage::_on_scripts_domain_unloaded() { void CSharpLanguage::_on_scripts_domain_unloaded() {
for (Map<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) { for (RBMap<Object *, CSharpScriptBinding>::Element *E = script_bindings.front(); E; E = E->next()) {
CSharpScriptBinding &script_binding = E->value(); CSharpScriptBinding &script_binding = E->value();
script_binding.inited = false; script_binding.inited = false;
} }
@ -1297,7 +1298,7 @@ bool CSharpLanguage::setup_csharp_script_binding(CSharpScriptBinding &r_script_b
void *CSharpLanguage::alloc_instance_binding_data(Object *p_object) { void *CSharpLanguage::alloc_instance_binding_data(Object *p_object) {
MutexLock lock(language_bind_mutex); MutexLock lock(language_bind_mutex);
Map<Object *, CSharpScriptBinding>::Element *match = script_bindings.find(p_object); RBMap<Object *, CSharpScriptBinding>::Element *match = script_bindings.find(p_object);
if (match) if (match)
return (void *)match; return (void *)match;
@ -1309,7 +1310,7 @@ void *CSharpLanguage::alloc_instance_binding_data(Object *p_object) {
return (void *)insert_script_binding(p_object, script_binding); return (void *)insert_script_binding(p_object, script_binding);
} }
Map<Object *, CSharpScriptBinding>::Element *CSharpLanguage::insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding) { RBMap<Object *, CSharpScriptBinding>::Element *CSharpLanguage::insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding) {
return script_bindings.insert(p_object, p_script_binding); return script_bindings.insert(p_object, p_script_binding);
} }
@ -1330,7 +1331,7 @@ void CSharpLanguage::free_instance_binding_data(void *p_data) {
{ {
MutexLock lock(language_bind_mutex); MutexLock lock(language_bind_mutex);
Map<Object *, CSharpScriptBinding>::Element *data = (Map<Object *, CSharpScriptBinding>::Element *)p_data; RBMap<Object *, CSharpScriptBinding>::Element *data = (RBMap<Object *, CSharpScriptBinding>::Element *)p_data;
CSharpScriptBinding &script_binding = data->value(); CSharpScriptBinding &script_binding = data->value();
@ -1358,7 +1359,7 @@ void CSharpLanguage::refcount_incremented_instance_binding(Object *p_object) {
void *data = p_object->get_script_instance_binding(get_language_index()); void *data = p_object->get_script_instance_binding(get_language_index());
CRASH_COND(!data); CRASH_COND(!data);
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
Ref<MonoGCHandle> &gchandle = script_binding.gchandle; Ref<MonoGCHandle> &gchandle = script_binding.gchandle;
if (!script_binding.inited) if (!script_binding.inited)
@ -1393,7 +1394,7 @@ bool CSharpLanguage::refcount_decremented_instance_binding(Object *p_object) {
void *data = p_object->get_script_instance_binding(get_language_index()); void *data = p_object->get_script_instance_binding(get_language_index());
CRASH_COND(!data); CRASH_COND(!data);
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
Ref<MonoGCHandle> &gchandle = script_binding.gchandle; Ref<MonoGCHandle> &gchandle = script_binding.gchandle;
int refcount = ref_owner->reference_get_count(); int refcount = ref_owner->reference_get_count();
@ -2164,7 +2165,7 @@ CSharpInstance::~CSharpInstance() {
void *data = owner->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index()); void *data = owner->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index());
CRASH_COND(data == NULL); CRASH_COND(data == NULL);
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
if (!script_binding.inited) { if (!script_binding.inited) {
MutexLock lock(CSharpLanguage::get_singleton()->get_language_bind_mutex()); MutexLock lock(CSharpLanguage::get_singleton()->get_language_bind_mutex());
@ -2187,7 +2188,7 @@ CSharpInstance::~CSharpInstance() {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
// CSharpInstance must not be created unless it's going to be added to the list for sure // CSharpInstance must not be created unless it's going to be added to the list for sure
Set<Object *>::Element *match = script->instances.find(owner); RBSet<Object *>::Element *match = script->instances.find(owner);
CRASH_COND(!match); CRASH_COND(!match);
script->instances.erase(match); script->instances.erase(match);
#else #else
@ -2203,12 +2204,12 @@ void CSharpScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder)
#endif #endif
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
void CSharpScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) { void CSharpScript::_update_exports_values(RBMap<StringName, Variant> &values, List<PropertyInfo> &propnames) {
if (base_cache.is_valid()) { if (base_cache.is_valid()) {
base_cache->_update_exports_values(values, propnames); base_cache->_update_exports_values(values, propnames);
} }
for (Map<StringName, Variant>::Element *E = exported_members_defval_cache.front(); E; E = E->next()) { for (RBMap<StringName, Variant>::Element *E = exported_members_defval_cache.front(); E; E = E->next()) {
values[E->key()] = E->get(); values[E->key()] = E->get();
} }
@ -2438,12 +2439,12 @@ bool CSharpScript::_update_exports(PlaceHolderScriptInstance *p_instance_to_upda
if ((changed || p_instance_to_update) && placeholders.size()) { if ((changed || p_instance_to_update) && placeholders.size()) {
// Update placeholders if any // Update placeholders if any
Map<StringName, Variant> values; RBMap<StringName, Variant> values;
List<PropertyInfo> propnames; List<PropertyInfo> propnames;
_update_exports_values(values, propnames); _update_exports_values(values, propnames);
if (changed) { if (changed) {
for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) { for (RBSet<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
E->get()->update(propnames, values); E->get()->update(propnames, values);
} }
} else { } else {
@ -2937,7 +2938,7 @@ CSharpInstance *CSharpScript::_create_instance(const Variant **p_args, int p_arg
void *data = p_owner->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index()); void *data = p_owner->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index());
CRASH_COND(data == NULL); CRASH_COND(data == NULL);
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
if (script_binding.inited && script_binding.gchandle.is_valid()) { if (script_binding.inited && script_binding.gchandle.is_valid()) {
MonoObject *mono_object = script_binding.gchandle->get_target(); MonoObject *mono_object = script_binding.gchandle->get_target();
if (mono_object) { if (mono_object) {
@ -3241,7 +3242,7 @@ ScriptLanguage *CSharpScript::get_language() const {
bool CSharpScript::get_property_default_value(const StringName &p_property, Variant &r_value) const { bool CSharpScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
const Map<StringName, Variant>::Element *E = exported_members_defval_cache.find(p_property); const RBMap<StringName, Variant>::Element *E = exported_members_defval_cache.find(p_property);
if (E) { if (E) {
r_value = E->get(); r_value = E->get();
return true; return true;
@ -3266,7 +3267,7 @@ bool CSharpScript::has_script_signal(const StringName &p_signal) const {
} }
void CSharpScript::get_script_signal_list(List<MethodInfo> *r_signals) const { void CSharpScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
for (const Map<StringName, Vector<Argument>>::Element *E = _signals.front(); E; E = E->next()) { for (const RBMap<StringName, Vector<Argument>>::Element *E = _signals.front(); E; E = E->next()) {
MethodInfo mi; MethodInfo mi;
mi.name = E->key(); mi.name = E->key();
@ -3367,10 +3368,10 @@ CSharpScript::~CSharpScript() {
#endif #endif
} }
void CSharpScript::get_members(Set<StringName> *p_members) { void CSharpScript::get_members(RBSet<StringName> *p_members) {
#if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED) #if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED)
if (p_members) { if (p_members) {
for (Set<StringName>::Element *E = exported_members_names.front(); E; E = E->next()) { for (RBSet<StringName>::Element *E = exported_members_names.front(); E; E = E->next()) {
p_members->insert(E->get()); p_members->insert(E->get());
} }
} }

32
csharp_script.h
View File

@ -33,8 +33,10 @@
#include "core/io/resource_loader.h" #include "core/io/resource_loader.h"
#include "core/io/resource_saver.h" #include "core/io/resource_saver.h"
#include "core/script_language.h" #include "core/object/script_language.h"
#include "core/self_list.h" #include "core/containers/self_list.h"
#include "core/containers/rb_set.h"
#include "core/containers/ordered_hash_map.h"
#include "mono_gc_handle.h" #include "mono_gc_handle.h"
#include "mono_gd/gd_mono.h" #include "mono_gd/gd_mono.h"
@ -84,7 +86,7 @@ class CSharpScript : public Script {
Ref<CSharpScript> base_cache; // TODO what's this for? Ref<CSharpScript> base_cache; // TODO what's this for?
Set<Object *> instances; RBSet<Object *> instances;
#ifdef GD_MONO_HOT_RELOAD #ifdef GD_MONO_HOT_RELOAD
struct StateBackup { struct StateBackup {
@ -94,8 +96,8 @@ class CSharpScript : public Script {
List<Pair<StringName, Variant>> properties; List<Pair<StringName, Variant>> properties;
}; };
Set<ObjectID> pending_reload_instances; RBSet<ObjectID> pending_reload_instances;
Map<ObjectID, StateBackup> pending_reload_state; RBMap<ObjectID, StateBackup> pending_reload_state;
StringName tied_class_name_for_reload; StringName tied_class_name_for_reload;
StringName tied_class_namespace_for_reload; StringName tied_class_namespace_for_reload;
#endif #endif
@ -110,23 +112,23 @@ class CSharpScript : public Script {
Variant::Type type; Variant::Type type;
}; };
Map<StringName, Vector<Argument>> _signals; RBMap<StringName, Vector<Argument>> _signals;
bool signals_invalidated; bool signals_invalidated;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
List<PropertyInfo> exported_members_cache; // members_cache List<PropertyInfo> exported_members_cache; // members_cache
Map<StringName, Variant> exported_members_defval_cache; // member_default_values_cache RBMap<StringName, Variant> exported_members_defval_cache; // member_default_values_cache
Set<PlaceHolderScriptInstance *> placeholders; RBSet<PlaceHolderScriptInstance *> placeholders;
bool source_changed_cache; bool source_changed_cache;
bool placeholder_fallback_enabled; bool placeholder_fallback_enabled;
bool exports_invalidated; bool exports_invalidated;
void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames); void _update_exports_values(RBMap<StringName, Variant> &values, List<PropertyInfo> &propnames);
void _update_member_info_no_exports(); void _update_member_info_no_exports();
virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder); virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
#endif #endif
#if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED) #if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED)
Set<StringName> exported_members_names; RBSet<StringName> exported_members_names;
#endif #endif
OrderedHashMap<StringName, PropertyInfo> member_info; OrderedHashMap<StringName, PropertyInfo> member_info;
@ -180,7 +182,7 @@ public:
virtual void get_script_property_list(List<PropertyInfo> *p_list) const; virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
virtual void update_exports(); virtual void update_exports();
virtual void get_members(Set<StringName> *p_members); virtual void get_members(RBSet<StringName> *p_members);
virtual bool is_tool() const { return tool; } virtual bool is_tool() const { return tool; }
virtual bool is_valid() const { return valid; } virtual bool is_valid() const { return valid; }
@ -312,11 +314,11 @@ class CSharpLanguage : public ScriptLanguage {
Mutex script_gchandle_release_mutex; Mutex script_gchandle_release_mutex;
Mutex language_bind_mutex; Mutex language_bind_mutex;
Map<Object *, CSharpScriptBinding> script_bindings; RBMap<Object *, CSharpScriptBinding> script_bindings;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
// List of unsafe object references // List of unsafe object references
Map<ObjectID, int> unsafe_object_references; RBMap<ObjectID, int> unsafe_object_references;
Mutex unsafe_object_references_lock; Mutex unsafe_object_references_lock;
#endif #endif
@ -409,7 +411,7 @@ public:
virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const; virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
virtual bool is_using_templates(); virtual bool is_using_templates();
virtual void make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script); virtual void make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script);
/* TODO */ virtual bool validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings = NULL, Set<int> *r_safe_lines = NULL) const { return true; } /* TODO */ virtual bool validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings = NULL, RBSet<int> *r_safe_lines = NULL) const { return true; }
virtual String validate_path(const String &p_path) const; virtual String validate_path(const String &p_path) const;
virtual Script *create_script() const; virtual Script *create_script() const;
virtual bool has_named_classes() const; virtual bool has_named_classes() const;
@ -464,7 +466,7 @@ public:
virtual void refcount_incremented_instance_binding(Object *p_object); virtual void refcount_incremented_instance_binding(Object *p_object);
virtual bool refcount_decremented_instance_binding(Object *p_object); virtual bool refcount_decremented_instance_binding(Object *p_object);
Map<Object *, CSharpScriptBinding>::Element *insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding); RBMap<Object *, CSharpScriptBinding>::Element *insert_script_binding(Object *p_object, const CSharpScriptBinding &p_script_binding);
bool setup_csharp_script_binding(CSharpScriptBinding &r_script_binding, Object *p_object); bool setup_csharp_script_binding(CSharpScriptBinding &r_script_binding, Object *p_object);
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED

72
editor/bindings_generator.cpp
View File

@ -32,13 +32,13 @@
#if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED) #if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED)
#include "core/engine.h" #include "core/config/engine.h"
#include "core/global_constants.h" #include "core/global_constants.h"
#include "core/io/compression.h" #include "core/io/compression.h"
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/ucaps.h" #include "core/string/ucaps.h"
#include "main/main.h" #include "main/main.h"
#include "../glue/cs_glue_version.gen.h" #include "../glue/cs_glue_version.gen.h"
@ -556,7 +556,7 @@ void BindingsGenerator::_append_xml_member(StringBuilder &p_xml_output, const Ty
void BindingsGenerator::_append_xml_enum(StringBuilder &p_xml_output, const TypeInterface *p_target_itype, const StringName &p_target_cname, const String &p_link_target, const Vector<String> &p_link_target_parts) { void BindingsGenerator::_append_xml_enum(StringBuilder &p_xml_output, const TypeInterface *p_target_itype, const StringName &p_target_cname, const String &p_link_target, const Vector<String> &p_link_target_parts) {
const StringName search_cname = !p_target_itype ? p_target_cname : StringName(p_target_itype->name + "." + (String)p_target_cname); const StringName search_cname = !p_target_itype ? p_target_cname : StringName(p_target_itype->name + "." + (String)p_target_cname);
const Map<StringName, TypeInterface>::Element *enum_match = enum_types.find(search_cname); const RBMap<StringName, TypeInterface>::Element *enum_match = enum_types.find(search_cname);
if (!enum_match && search_cname != p_target_cname) { if (!enum_match && search_cname != p_target_cname) {
enum_match = enum_types.find(p_target_cname); enum_match = enum_types.find(p_target_cname);
@ -1747,7 +1747,7 @@ Error BindingsGenerator::_generate_cs_method(const BindingsGenerator::TypeInterf
return OK; // Won't increment method bind count return OK; // Won't increment method bind count
} }
const Map<const MethodInterface *, const InternalCall *>::Element *match = method_icalls_map.find(&p_imethod); const RBMap<const MethodInterface *, const InternalCall *>::Element *match = method_icalls_map.find(&p_imethod);
ERR_FAIL_NULL_V(match, ERR_BUG); ERR_FAIL_NULL_V(match, ERR_BUG);
const InternalCall *im_icall = match->value(); const InternalCall *im_icall = match->value();
@ -2011,7 +2011,7 @@ Error BindingsGenerator::_generate_glue_method(const BindingsGenerator::TypeInte
i++; i++;
} }
const Map<const MethodInterface *, const InternalCall *>::Element *match = method_icalls_map.find(&p_imethod); const RBMap<const MethodInterface *, const InternalCall *>::Element *match = method_icalls_map.find(&p_imethod);
ERR_FAIL_NULL_V(match, ERR_BUG); ERR_FAIL_NULL_V(match, ERR_BUG);
const InternalCall *im_icall = match->value(); const InternalCall *im_icall = match->value();
@ -2147,7 +2147,7 @@ Error BindingsGenerator::_generate_glue_method(const BindingsGenerator::TypeInte
} }
const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_null(const TypeReference &p_typeref) { const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_null(const TypeReference &p_typeref) {
const Map<StringName, TypeInterface>::Element *builtin_type_match = builtin_types.find(p_typeref.cname); const RBMap<StringName, TypeInterface>::Element *builtin_type_match = builtin_types.find(p_typeref.cname);
if (builtin_type_match) if (builtin_type_match)
return &builtin_type_match->get(); return &builtin_type_match->get();
@ -2158,13 +2158,13 @@ const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_null(con
return &obj_type_match.get(); return &obj_type_match.get();
if (p_typeref.is_enum) { if (p_typeref.is_enum) {
const Map<StringName, TypeInterface>::Element *enum_match = enum_types.find(p_typeref.cname); const RBMap<StringName, TypeInterface>::Element *enum_match = enum_types.find(p_typeref.cname);
if (enum_match) if (enum_match)
return &enum_match->get(); return &enum_match->get();
// Enum not found. Most likely because none of its constants were bound, so it's empty. That's fine. Use int instead. // Enum not found. Most likely because none of its constants were bound, so it's empty. That's fine. Use int instead.
const Map<StringName, TypeInterface>::Element *int_match = builtin_types.find(name_cache.type_int); const RBMap<StringName, TypeInterface>::Element *int_match = builtin_types.find(name_cache.type_int);
ERR_FAIL_NULL_V(int_match, NULL); ERR_FAIL_NULL_V(int_match, NULL);
return &int_match->get(); return &int_match->get();
} }
@ -2180,7 +2180,7 @@ const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_placehol
ERR_PRINT(String() + "Type not found. Creating placeholder: '" + p_typeref.cname.operator String() + "'."); ERR_PRINT(String() + "Type not found. Creating placeholder: '" + p_typeref.cname.operator String() + "'.");
const Map<StringName, TypeInterface>::Element *match = placeholder_types.find(p_typeref.cname); const RBMap<StringName, TypeInterface>::Element *match = placeholder_types.find(p_typeref.cname);
if (match) if (match)
return &match->get(); return &match->get();
@ -2191,30 +2191,30 @@ const BindingsGenerator::TypeInterface *BindingsGenerator::_get_type_or_placehol
return &placeholder_types.insert(placeholder.cname, placeholder)->get(); return &placeholder_types.insert(placeholder.cname, placeholder)->get();
} }
StringName BindingsGenerator::_get_int_type_name_from_meta(GodotTypeInfo::Metadata p_meta) { StringName BindingsGenerator::_get_int_type_name_from_meta(PandemoniumTypeInfo::Metadata p_meta) {
switch (p_meta) { switch (p_meta) {
case GodotTypeInfo::METADATA_INT_IS_INT8: case PandemoniumTypeInfo::METADATA_INT_IS_INT8:
return "sbyte"; return "sbyte";
break; break;
case GodotTypeInfo::METADATA_INT_IS_INT16: case PandemoniumTypeInfo::METADATA_INT_IS_INT16:
return "short"; return "short";
break; break;
case GodotTypeInfo::METADATA_INT_IS_INT32: case PandemoniumTypeInfo::METADATA_INT_IS_INT32:
return "int"; return "int";
break; break;
case GodotTypeInfo::METADATA_INT_IS_INT64: case PandemoniumTypeInfo::METADATA_INT_IS_INT64:
return "long"; return "long";
break; break;
case GodotTypeInfo::METADATA_INT_IS_UINT8: case PandemoniumTypeInfo::METADATA_INT_IS_UINT8:
return "byte"; return "byte";
break; break;
case GodotTypeInfo::METADATA_INT_IS_UINT16: case PandemoniumTypeInfo::METADATA_INT_IS_UINT16:
return "ushort"; return "ushort";
break; break;
case GodotTypeInfo::METADATA_INT_IS_UINT32: case PandemoniumTypeInfo::METADATA_INT_IS_UINT32:
return "uint"; return "uint";
break; break;
case GodotTypeInfo::METADATA_INT_IS_UINT64: case PandemoniumTypeInfo::METADATA_INT_IS_UINT64:
return "ulong"; return "ulong";
break; break;
default: default:
@ -2223,12 +2223,12 @@ StringName BindingsGenerator::_get_int_type_name_from_meta(GodotTypeInfo::Metada
} }
} }
StringName BindingsGenerator::_get_float_type_name_from_meta(GodotTypeInfo::Metadata p_meta) { StringName BindingsGenerator::_get_float_type_name_from_meta(PandemoniumTypeInfo::Metadata p_meta) {
switch (p_meta) { switch (p_meta) {
case GodotTypeInfo::METADATA_REAL_IS_FLOAT: case PandemoniumTypeInfo::METADATA_REAL_IS_FLOAT:
return "float"; return "float";
break; break;
case GodotTypeInfo::METADATA_REAL_IS_DOUBLE: case PandemoniumTypeInfo::METADATA_REAL_IS_DOUBLE:
return "double"; return "double";
break; break;
default: default:
@ -2298,7 +2298,7 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
List<PropertyInfo> property_list; List<PropertyInfo> property_list;
ClassDB::get_property_list(type_cname, &property_list, true); ClassDB::get_property_list(type_cname, &property_list, true);
Map<StringName, StringName> accessor_methods; RBMap<StringName, StringName> accessor_methods;
for (const List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) { for (const List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
const PropertyInfo &property = E->get(); const PropertyInfo &property = E->get();
@ -2423,9 +2423,9 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
imethod.return_type.cname = name_cache.type_void; imethod.return_type.cname = name_cache.type_void;
} else { } else {
if (return_info.type == Variant::INT) { if (return_info.type == Variant::INT) {
imethod.return_type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(-1) : GodotTypeInfo::METADATA_NONE); imethod.return_type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(-1) : PandemoniumTypeInfo::METADATA_NONE);
} else if (return_info.type == Variant::REAL) { } else if (return_info.type == Variant::REAL) {
imethod.return_type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(-1) : GodotTypeInfo::METADATA_NONE); imethod.return_type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(-1) : PandemoniumTypeInfo::METADATA_NONE);
} else { } else {
imethod.return_type.cname = Variant::get_type_name(return_info.type); imethod.return_type.cname = Variant::get_type_name(return_info.type);
} }
@ -2450,9 +2450,9 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
iarg.type.cname = name_cache.type_Variant; iarg.type.cname = name_cache.type_Variant;
} else { } else {
if (arginfo.type == Variant::INT) { if (arginfo.type == Variant::INT) {
iarg.type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(i) : GodotTypeInfo::METADATA_NONE); iarg.type.cname = _get_int_type_name_from_meta(m ? m->get_argument_meta(i) : PandemoniumTypeInfo::METADATA_NONE);
} else if (arginfo.type == Variant::REAL) { } else if (arginfo.type == Variant::REAL) {
iarg.type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(i) : GodotTypeInfo::METADATA_NONE); iarg.type.cname = _get_float_type_name_from_meta(m ? m->get_argument_meta(i) : PandemoniumTypeInfo::METADATA_NONE);
} else { } else {
iarg.type.cname = Variant::get_type_name(arginfo.type); iarg.type.cname = Variant::get_type_name(arginfo.type);
} }
@ -2486,7 +2486,7 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
imethod.proxy_name += "_"; imethod.proxy_name += "_";
} }
Map<StringName, StringName>::Element *accessor = accessor_methods.find(imethod.cname); RBMap<StringName, StringName>::Element *accessor = accessor_methods.find(imethod.cname);
if (accessor) { if (accessor) {
const PropertyInterface *accessor_property = itype.find_property_by_name(accessor->value()); const PropertyInterface *accessor_property = itype.find_property_by_name(accessor->value());
@ -2673,7 +2673,7 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
r_iarg.default_argument = "new %s()"; r_iarg.default_argument = "new %s()";
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_REF; r_iarg.def_param_mode = ArgumentInterface::NULLABLE_REF;
break; break;
case Variant::_RID: case Variant::RID:
ERR_FAIL_COND_V_MSG(r_iarg.type.cname != name_cache.type_RID, false, ERR_FAIL_COND_V_MSG(r_iarg.type.cname != name_cache.type_RID, false,
"Parameter of type '" + String(r_iarg.type.cname) + "' cannot have a default value of type '" + String(name_cache.type_RID) + "'."); "Parameter of type '" + String(r_iarg.type.cname) + "' cannot have a default value of type '" + String(name_cache.type_RID) + "'.");
@ -2701,7 +2701,7 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
if (transform == Transform2D()) { if (transform == Transform2D()) {
r_iarg.default_argument = "Transform2D.Identity"; r_iarg.default_argument = "Transform2D.Identity";
} else { } else {
r_iarg.default_argument = "new Transform2D(new Vector2" + transform.elements[0].operator String() + ", new Vector2" + transform.elements[1].operator String() + ", new Vector2" + transform.elements[2].operator String() + ")"; r_iarg.default_argument = "new Transform2D(new Vector2" + transform.columns[0].operator String() + ", new Vector2" + transform.columns[1].operator String() + ", new Vector2" + transform.columns[2].operator String() + ")";
} }
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL; r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
} break; } break;
@ -2724,12 +2724,12 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
} }
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL; r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
} break; } break;
case Variant::QUAT: { case Variant::QUATERNION: {
Quat quat = p_val.operator Quat(); Quaternion quat = p_val.operator Quaternion();
if (quat == Quat()) { if (quat == Quaternion()) {
r_iarg.default_argument = "Quat.Identity"; r_iarg.default_argument = "Quaternion.Identity";
} else { } else {
r_iarg.default_argument = "new Quat" + quat.operator String(); r_iarg.default_argument = "new Quaternion" + quat.operator String();
} }
r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL; r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
} break; } break;
@ -2770,7 +2770,7 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
INSERT_STRUCT_TYPE(Transform2D) INSERT_STRUCT_TYPE(Transform2D)
INSERT_STRUCT_TYPE(Vector3) INSERT_STRUCT_TYPE(Vector3)
INSERT_STRUCT_TYPE(Basis) INSERT_STRUCT_TYPE(Basis)
INSERT_STRUCT_TYPE(Quat) INSERT_STRUCT_TYPE(Quaternion)
INSERT_STRUCT_TYPE(Transform) INSERT_STRUCT_TYPE(Transform)
INSERT_STRUCT_TYPE(AABB) INSERT_STRUCT_TYPE(AABB)
INSERT_STRUCT_TYPE(Color) INSERT_STRUCT_TYPE(Color)
@ -3027,7 +3027,7 @@ void BindingsGenerator::_populate_global_constants() {
int global_constants_count = GlobalConstants::get_global_constant_count(); int global_constants_count = GlobalConstants::get_global_constant_count();
if (global_constants_count > 0) { if (global_constants_count > 0) {
Map<String, DocData::ClassDoc>::Element *match = EditorHelp::get_doc_data()->class_list.find("@GlobalScope"); RBMap<String, DocData::ClassDoc>::Element *match = EditorHelp::get_doc_data()->class_list.find("@GlobalScope");
CRASH_COND_MSG(!match, "Could not find '@GlobalScope' in DocData."); CRASH_COND_MSG(!match, "Could not find '@GlobalScope' in DocData.");

21
editor/bindings_generator.h
View File

@ -31,14 +31,15 @@
#ifndef BINDINGS_GENERATOR_H #ifndef BINDINGS_GENERATOR_H
#define BINDINGS_GENERATOR_H #define BINDINGS_GENERATOR_H
#include "core/class_db.h" #include "core/object/class_db.h"
#include "core/string_builder.h" #include "core/containers/ordered_hash_map.h"
#include "core/string/string_builder.h"
#include "editor/doc/doc_data.h" #include "editor/doc/doc_data.h"
#include "editor/editor_help.h" #include "editor/editor_help.h"
#if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED) #if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED)
#include "core/ustring.h" #include "core/string/ustring.h"
class BindingsGenerator { class BindingsGenerator {
struct ConstantInterface { struct ConstantInterface {
@ -493,22 +494,22 @@ class BindingsGenerator {
OrderedHashMap<StringName, TypeInterface> obj_types; OrderedHashMap<StringName, TypeInterface> obj_types;
Map<StringName, TypeInterface> placeholder_types; RBMap<StringName, TypeInterface> placeholder_types;
Map<StringName, TypeInterface> builtin_types; RBMap<StringName, TypeInterface> builtin_types;
Map<StringName, TypeInterface> enum_types; RBMap<StringName, TypeInterface> enum_types;
List<EnumInterface> global_enums; List<EnumInterface> global_enums;
List<ConstantInterface> global_constants; List<ConstantInterface> global_constants;
List<InternalCall> method_icalls; List<InternalCall> method_icalls;
Map<const MethodInterface *, const InternalCall *> method_icalls_map; RBMap<const MethodInterface *, const InternalCall *> method_icalls_map;
List<const InternalCall *> generated_icall_funcs; List<const InternalCall *> generated_icall_funcs;
List<InternalCall> core_custom_icalls; List<InternalCall> core_custom_icalls;
List<InternalCall> editor_custom_icalls; List<InternalCall> editor_custom_icalls;
Map<StringName, List<StringName>> blacklisted_methods; RBMap<StringName, List<StringName>> blacklisted_methods;
void _initialize_blacklisted_methods(); void _initialize_blacklisted_methods();
@ -617,8 +618,8 @@ class BindingsGenerator {
const TypeInterface *_get_type_or_null(const TypeReference &p_typeref); const TypeInterface *_get_type_or_null(const TypeReference &p_typeref);
const TypeInterface *_get_type_or_placeholder(const TypeReference &p_typeref); const TypeInterface *_get_type_or_placeholder(const TypeReference &p_typeref);
StringName _get_int_type_name_from_meta(GodotTypeInfo::Metadata p_meta); StringName _get_int_type_name_from_meta(PandemoniumTypeInfo::Metadata p_meta);
StringName _get_float_type_name_from_meta(GodotTypeInfo::Metadata p_meta); StringName _get_float_type_name_from_meta(PandemoniumTypeInfo::Metadata p_meta);
bool _arg_default_value_from_variant(const Variant &p_val, ArgumentInterface &r_iarg); bool _arg_default_value_from_variant(const Variant &p_val, ArgumentInterface &r_iarg);

2
editor/code_completion.cpp
View File

@ -30,7 +30,7 @@
#include "code_completion.h" #include "code_completion.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "editor/editor_file_system.h" #include "editor/editor_file_system.h"
#include "editor/editor_settings.h" #include "editor/editor_settings.h"
#include "scene/gui/control.h" #include "scene/gui/control.h"

4
editor/code_completion.h
View File

@ -31,8 +31,8 @@
#ifndef CODE_COMPLETION_H #ifndef CODE_COMPLETION_H
#define CODE_COMPLETION_H #define CODE_COMPLETION_H
#include "core/ustring.h" #include "core/string/ustring.h"
#include "core/variant.h" #include "core/variant/variant.h"
namespace gdmono { namespace gdmono {

2
editor/csharp_project.cpp
View File

@ -34,7 +34,7 @@
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "../csharp_script.h" #include "../csharp_script.h"
#include "../mono_gd/gd_mono_class.h" #include "../mono_gd/gd_mono_class.h"

2
editor/csharp_project.h
View File

@ -31,7 +31,7 @@
#ifndef CSHARP_PROJECT_H #ifndef CSHARP_PROJECT_H
#define CSHARP_PROJECT_H #define CSHARP_PROJECT_H
#include "core/ustring.h" #include "core/string/ustring.h"
namespace CSharpProject { namespace CSharpProject {

13
editor/editor_internal_calls.cpp
View File

@ -38,9 +38,12 @@
#include "core/version.h" #include "core/version.h"
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_scale.h" #include "editor/editor_scale.h"
#include "editor/plugins/script_editor_plugin.h" #include "editor/editor_settings.h"
#include "editor/script_editor_debugger.h" #include "editor/script_editor_debugger.h"
#include "editor_code_editor/script_editor_plugin.h"
#include "editor_code_editor/editor_script_editor.h"
#include "main/main.h" #include "main/main.h"
#include "core/config/project_settings.h"
#include "../csharp_script.h" #include "../csharp_script.h"
#include "../glue/cs_glue_version.gen.h" #include "../glue/cs_glue_version.gen.h"
@ -285,16 +288,16 @@ void godot_icall_Internal_ReloadAssemblies(MonoBoolean p_soft_reload) {
} }
void godot_icall_Internal_ScriptEditorDebuggerReloadScripts() { void godot_icall_Internal_ScriptEditorDebuggerReloadScripts() {
ScriptEditor::get_singleton()->get_debugger()->reload_scripts(); EditorScriptEditor::get_singleton()->get_debugger()->reload_scripts();
} }
MonoBoolean godot_icall_Internal_ScriptEditorEdit(MonoObject *p_resource, int32_t p_line, int32_t p_col, MonoBoolean p_grab_focus) { MonoBoolean godot_icall_Internal_ScriptEditorEdit(MonoObject *p_resource, int32_t p_line, int32_t p_col, MonoBoolean p_grab_focus) {
Ref<Resource> resource = GDMonoMarshal::mono_object_to_variant(p_resource); Ref<Resource> resource = GDMonoMarshal::mono_object_to_variant(p_resource);
return (MonoBoolean)ScriptEditor::get_singleton()->edit(resource, p_line, p_col, (bool)p_grab_focus); return (MonoBoolean)EditorScriptEditor::get_singleton()->edit(resource, p_line, p_col, (bool)p_grab_focus);
} }
void godot_icall_Internal_EditorNodeShowScriptScreen() { void godot_icall_Internal_EditorNodeShowScriptScreen() {
EditorNode::get_singleton()->call("_editor_select", EditorNode::EDITOR_SCRIPT); EditorNode::get_singleton()->call("_editor_select", 2);
} }
MonoObject *godot_icall_Internal_GetScriptsMetadataOrNothing(MonoReflectionType *p_dict_reftype) { MonoObject *godot_icall_Internal_GetScriptsMetadataOrNothing(MonoReflectionType *p_dict_reftype) {
@ -327,7 +330,7 @@ void godot_icall_Internal_EditorRunStop() {
} }
void godot_icall_Internal_ScriptEditorDebugger_ReloadScripts() { void godot_icall_Internal_ScriptEditorDebugger_ReloadScripts() {
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger(); EditorScriptEditorDebugger *sed = EditorScriptEditor::get_singleton()->get_debugger();
if (sed) { if (sed) {
sed->reload_scripts(); sed->reload_scripts();
} }

2
editor/godotsharp_export.cpp
View File

@ -34,7 +34,7 @@
#include "core/io/file_access_pack.h" #include "core/io/file_access_pack.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "../mono_gd/gd_mono.h" #include "../mono_gd/gd_mono.h"
#include "../mono_gd/gd_mono_assembly.h" #include "../mono_gd/gd_mono_assembly.h"

6
editor/godotsharp_export.h
View File

@ -31,9 +31,9 @@
#ifndef GODOTSHARP_EXPORT_H #ifndef GODOTSHARP_EXPORT_H
#define GODOTSHARP_EXPORT_H #define GODOTSHARP_EXPORT_H
#include "core/dictionary.h" #include "core/variant/dictionary.h"
#include "core/error_list.h" #include "core/error/error_list.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "../mono_gd/gd_mono_header.h" #include "../mono_gd/gd_mono_header.h"

6
editor/script_class_parser.cpp
View File

@ -30,7 +30,7 @@
#include "script_class_parser.h" #include "script_class_parser.h"
#include "core/map.h" #include "core/containers/rb_map.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "../utils/string_utils.h" #include "../utils/string_utils.h"
@ -504,7 +504,7 @@ Error ScriptClassParser::parse(const String &p_code) {
Token tk = get_token(); Token tk = get_token();
Map<int, NameDecl> name_stack; RBMap<int, NameDecl> name_stack;
int curly_stack = 0; int curly_stack = 0;
int type_curly_stack = 0; int type_curly_stack = 0;
@ -521,7 +521,7 @@ Error ScriptClassParser::parse(const String &p_code) {
ClassDecl class_decl; ClassDecl class_decl;
for (Map<int, NameDecl>::Element *E = name_stack.front(); E; E = E->next()) { for (RBMap<int, NameDecl>::Element *E = name_stack.front(); E; E = E->next()) {
const NameDecl &name_decl = E->value(); const NameDecl &name_decl = E->value();
if (name_decl.type == NameDecl::NAMESPACE_DECL) { if (name_decl.type == NameDecl::NAMESPACE_DECL) {

6
editor/script_class_parser.h
View File

@ -31,9 +31,9 @@
#ifndef SCRIPT_CLASS_PARSER_H #ifndef SCRIPT_CLASS_PARSER_H
#define SCRIPT_CLASS_PARSER_H #define SCRIPT_CLASS_PARSER_H
#include "core/ustring.h" #include "core/string/ustring.h"
#include "core/variant.h" #include "core/variant/variant.h"
#include "core/vector.h" #include "core/containers/vector.h"
class ScriptClassParser { class ScriptClassParser {
public: public:

40
glue/GodotSharp/GodotSharp/Core/Basis.cs
View File

@ -226,12 +226,12 @@ namespace Godot
/// <summary> /// <summary>
/// Returns the <see cref="Basis"/>'s rotation in the form of a /// Returns the <see cref="Basis"/>'s rotation in the form of a
/// <see cref="Quat"/>. See <see cref="GetEuler"/> if you /// <see cref="Quaternion"/>. See <see cref="GetEuler"/> if you
/// need Euler angles, but keep in mind quaternions should generally /// need Euler angles, but keep in mind quaternions should generally
/// be preferred to Euler angles. /// be preferred to Euler angles.
/// </summary> /// </summary>
/// <returns>The basis rotation.</returns> /// <returns>The basis rotation.</returns>
public Quat RotationQuat() public Quaternion RotationQuaternion()
{ {
Basis orthonormalizedBasis = Orthonormalized(); Basis orthonormalizedBasis = Orthonormalized();
real_t det = orthonormalizedBasis.Determinant(); real_t det = orthonormalizedBasis.Determinant();
@ -242,16 +242,16 @@ namespace Godot
orthonormalizedBasis = orthonormalizedBasis.Scaled(-Vector3.One); orthonormalizedBasis = orthonormalizedBasis.Scaled(-Vector3.One);
} }
return orthonormalizedBasis.Quat(); return orthonormalizedBasis.Quaternion();
} }
internal void SetQuatScale(Quat quaternion, Vector3 scale) internal void SetQuaternionScale(Quaternion quaternion, Vector3 scale)
{ {
SetDiagonal(scale); SetDiagonal(scale);
Rotate(quaternion); Rotate(quaternion);
} }
private void Rotate(Quat quaternion) private void Rotate(Quaternion quaternion)
{ {
this *= new Basis(quaternion); this *= new Basis(quaternion);
} }
@ -287,8 +287,8 @@ namespace Godot
/// The returned vector contains the rotation angles in /// The returned vector contains the rotation angles in
/// the format (X angle, Y angle, Z angle). /// the format (X angle, Y angle, Z angle).
/// ///
/// Consider using the <see cref="RotationQuat"/> method instead, which /// Consider using the <see cref="RotationQuaternion"/> method instead, which
/// returns a <see cref="Godot.Quat"/> quaternion instead of Euler angles. /// returns a <see cref="Godot.Quaternion"/> quaternion instead of Euler angles.
/// </summary> /// </summary>
/// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns> /// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns>
public Vector3 GetEuler() public Vector3 GetEuler()
@ -303,8 +303,8 @@ namespace Godot
/// first Z, then X, and Y last. The returned vector contains /// first Z, then X, and Y last. The returned vector contains
/// the rotation angles in the format (X angle, Y angle, Z angle). /// the rotation angles in the format (X angle, Y angle, Z angle).
/// ///
/// Consider using the <see cref="RotationQuat"/> method instead, which /// Consider using the <see cref="RotationQuaternion"/> method instead, which
/// returns a <see cref="Godot.Quat"/> quaternion instead of Euler angles. /// returns a <see cref="Godot.Quaternion"/> quaternion instead of Euler angles.
/// </summary> /// </summary>
/// <param name="order">The Euler order to use.</param> /// <param name="order">The Euler order to use.</param>
/// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns> /// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns>
@ -772,8 +772,8 @@ namespace Godot
/// <returns>The resulting basis matrix of the interpolation.</returns> /// <returns>The resulting basis matrix of the interpolation.</returns>
public Basis Slerp(Basis target, real_t weight) public Basis Slerp(Basis target, real_t weight)
{ {
Quat from = new Quat(this); Quaternion from = new Quaternion(this);
Quat to = new Quat(target); Quaternion to = new Quaternion(target);
Basis b = new Basis(from.Slerp(to, weight)); Basis b = new Basis(from.Slerp(to, weight));
b.Row0 *= Mathf.Lerp(Row0.Length(), target.Row0.Length(), weight); b.Row0 *= Mathf.Lerp(Row0.Length(), target.Row0.Length(), weight);
@ -876,8 +876,8 @@ namespace Godot
/// See <see cref="GetEuler"/> if you need Euler angles, but keep in /// See <see cref="GetEuler"/> if you need Euler angles, but keep in
/// mind that quaternions should generally be preferred to Euler angles. /// mind that quaternions should generally be preferred to Euler angles.
/// </summary> /// </summary>
/// <returns>A <see cref="Godot.Quat"/> representing the basis's rotation.</returns> /// <returns>A <see cref="Godot.Quaternion"/> representing the basis's rotation.</returns>
public Quat Quat() public Quaternion Quaternion()
{ {
real_t trace = Row0[0] + Row1[1] + Row2[2]; real_t trace = Row0[0] + Row1[1] + Row2[2];
@ -885,7 +885,7 @@ namespace Godot
{ {
real_t s = Mathf.Sqrt(trace + 1.0f) * 2f; real_t s = Mathf.Sqrt(trace + 1.0f) * 2f;
real_t inv_s = 1f / s; real_t inv_s = 1f / s;
return new Quat( return new Quaternion(
(Row2[1] - Row1[2]) * inv_s, (Row2[1] - Row1[2]) * inv_s,
(Row0[2] - Row2[0]) * inv_s, (Row0[2] - Row2[0]) * inv_s,
(Row1[0] - Row0[1]) * inv_s, (Row1[0] - Row0[1]) * inv_s,
@ -897,7 +897,7 @@ namespace Godot
{ {
real_t s = Mathf.Sqrt(Row0[0] - Row1[1] - Row2[2] + 1.0f) * 2f; real_t s = Mathf.Sqrt(Row0[0] - Row1[1] - Row2[2] + 1.0f) * 2f;
real_t inv_s = 1f / s; real_t inv_s = 1f / s;
return new Quat( return new Quaternion(
s * 0.25f, s * 0.25f,
(Row0[1] + Row1[0]) * inv_s, (Row0[1] + Row1[0]) * inv_s,
(Row0[2] + Row2[0]) * inv_s, (Row0[2] + Row2[0]) * inv_s,
@ -909,7 +909,7 @@ namespace Godot
{ {
real_t s = Mathf.Sqrt(-Row0[0] + Row1[1] - Row2[2] + 1.0f) * 2f; real_t s = Mathf.Sqrt(-Row0[0] + Row1[1] - Row2[2] + 1.0f) * 2f;
real_t inv_s = 1f / s; real_t inv_s = 1f / s;
return new Quat( return new Quaternion(
(Row0[1] + Row1[0]) * inv_s, (Row0[1] + Row1[0]) * inv_s,
s * 0.25f, s * 0.25f,
(Row1[2] + Row2[1]) * inv_s, (Row1[2] + Row2[1]) * inv_s,
@ -920,7 +920,7 @@ namespace Godot
{ {
real_t s = Mathf.Sqrt(-Row0[0] - Row1[1] + Row2[2] + 1.0f) * 2f; real_t s = Mathf.Sqrt(-Row0[0] - Row1[1] + Row2[2] + 1.0f) * 2f;
real_t inv_s = 1f / s; real_t inv_s = 1f / s;
return new Quat( return new Quaternion(
(Row0[2] + Row2[0]) * inv_s, (Row0[2] + Row2[0]) * inv_s,
(Row1[2] + Row2[1]) * inv_s, (Row1[2] + Row2[1]) * inv_s,
s * 0.25f, s * 0.25f,
@ -988,7 +988,7 @@ namespace Godot
/// Constructs a pure rotation basis matrix from the given quaternion. /// Constructs a pure rotation basis matrix from the given quaternion.
/// </summary> /// </summary>
/// <param name="quaternion">The quaternion to create the basis from.</param> /// <param name="quaternion">The quaternion to create the basis from.</param>
public Basis(Quat quaternion) public Basis(Quaternion quaternion)
{ {
real_t s = 2.0f / quaternion.LengthSquared; real_t s = 2.0f / quaternion.LengthSquared;
@ -1015,8 +1015,8 @@ namespace Godot
/// (in the YXZ convention: when *composing*, first Y, then X, and Z last), /// (in the YXZ convention: when *composing*, first Y, then X, and Z last),
/// given in the vector format as (X angle, Y angle, Z angle). /// given in the vector format as (X angle, Y angle, Z angle).
/// ///
/// Consider using the <see cref="Basis(Quat)"/> constructor instead, which /// Consider using the <see cref="Basis(Quaternion)"/> constructor instead, which
/// uses a <see cref="Godot.Quat"/> quaternion instead of Euler angles. /// uses a <see cref="Godot.Quaternion"/> quaternion instead of Euler angles.
/// </summary> /// </summary>
/// <param name="eulerYXZ">The Euler angles to create the basis from.</param> /// <param name="eulerYXZ">The Euler angles to create the basis from.</param>
public Basis(Vector3 eulerYXZ) public Basis(Vector3 eulerYXZ)

162
glue/GodotSharp/GodotSharp/Core/Quat.cs → glue/GodotSharp/GodotSharp/Core/Quaternion.cs
View File

@ -10,12 +10,12 @@ namespace Godot
{ {
/// <summary> /// <summary>
/// A unit quaternion used for representing 3D rotations. /// A unit quaternion used for representing 3D rotations.
/// Quaternions need to be normalized to be used for rotation. /// Quaternionernions need to be normalized to be used for rotation.
/// ///
/// It is similar to <see cref="Basis"/>, which implements matrix /// It is similar to <see cref="Basis"/>, which implements matrix
/// representation of rotations, and can be parametrized using both /// representation of rotations, and can be parametrized using both
/// an axis-angle pair or Euler angles. Basis stores rotation, scale, /// an axis-angle pair or Euler angles. Basis stores rotation, scale,
/// and shearing, while Quat only stores rotation. /// and shearing, while Quaternion only stores rotation.
/// ///
/// Due to its compactness and the way it is stored in memory, certain /// Due to its compactness and the way it is stored in memory, certain
/// operations (obtaining axis-angle and performing SLERP, in particular) /// operations (obtaining axis-angle and performing SLERP, in particular)
@ -23,29 +23,29 @@ namespace Godot
/// </summary> /// </summary>
[Serializable] [Serializable]
[StructLayout(LayoutKind.Sequential)] [StructLayout(LayoutKind.Sequential)]
public struct Quat : IEquatable<Quat> public struct Quaternion : IEquatable<Quaternion>
{ {
/// <summary> /// <summary>
/// X component of the quaternion (imaginary <c>i</c> axis part). /// X component of the quaternion (imaginary <c>i</c> axis part).
/// Quaternion components should usually not be manipulated directly. /// Quaternionernion components should usually not be manipulated directly.
/// </summary> /// </summary>
public real_t x; public real_t x;
/// <summary> /// <summary>
/// Y component of the quaternion (imaginary <c>j</c> axis part). /// Y component of the quaternion (imaginary <c>j</c> axis part).
/// Quaternion components should usually not be manipulated directly. /// Quaternionernion components should usually not be manipulated directly.
/// </summary> /// </summary>
public real_t y; public real_t y;
/// <summary> /// <summary>
/// Z component of the quaternion (imaginary <c>k</c> axis part). /// Z component of the quaternion (imaginary <c>k</c> axis part).
/// Quaternion components should usually not be manipulated directly. /// Quaternionernion components should usually not be manipulated directly.
/// </summary> /// </summary>
public real_t z; public real_t z;
/// <summary> /// <summary>
/// W component of the quaternion (real part). /// W component of the quaternion (real part).
/// Quaternion components should usually not be manipulated directly. /// Quaternionernion components should usually not be manipulated directly.
/// </summary> /// </summary>
public real_t w; public real_t w;
@ -130,7 +130,7 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="to">The other quaternion.</param> /// <param name="to">The other quaternion.</param>
/// <returns>The angle between the quaternions.</returns> /// <returns>The angle between the quaternions.</returns>
public real_t AngleTo(Quat to) public real_t AngleTo(Quaternion to)
{ {
real_t dot = Dot(to); real_t dot = Dot(to);
return Mathf.Acos(Mathf.Clamp(dot * dot * 2 - 1, -1, 1)); return Mathf.Acos(Mathf.Clamp(dot * dot * 2 - 1, -1, 1));
@ -145,11 +145,11 @@ namespace Godot
/// <param name="postB">A quaternion after <paramref name="b"/>.</param> /// <param name="postB">A quaternion after <paramref name="b"/>.</param>
/// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param> /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
/// <returns>The interpolated quaternion.</returns> /// <returns>The interpolated quaternion.</returns>
public Quat CubicSlerp(Quat b, Quat preA, Quat postB, real_t weight) public Quaternion CubicSlerp(Quaternion b, Quaternion preA, Quaternion postB, real_t weight)
{ {
real_t t2 = (1.0f - weight) * weight * 2f; real_t t2 = (1.0f - weight) * weight * 2f;
Quat sp = Slerp(b, weight); Quaternion sp = Slerp(b, weight);
Quat sq = preA.Slerpni(postB, weight); Quaternion sq = preA.Slerpni(postB, weight);
return sp.Slerpni(sq, t2); return sp.Slerpni(sq, t2);
} }
@ -158,7 +158,7 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="b">The other quaternion.</param> /// <param name="b">The other quaternion.</param>
/// <returns>The dot product.</returns> /// <returns>The dot product.</returns>
public real_t Dot(Quat b) public real_t Dot(Quaternion b)
{ {
return (x * b.x) + (y * b.y) + (z * b.z) + (w * b.w); return (x * b.x) + (y * b.y) + (z * b.z) + (w * b.w);
} }
@ -175,7 +175,7 @@ namespace Godot
#if DEBUG #if DEBUG
if (!IsNormalized()) if (!IsNormalized())
{ {
throw new InvalidOperationException("Quat is not normalized"); throw new InvalidOperationException("Quaternion is not normalized");
} }
#endif #endif
var basis = new Basis(this); var basis = new Basis(this);
@ -186,15 +186,15 @@ namespace Godot
/// Returns the inverse of the quaternion. /// Returns the inverse of the quaternion.
/// </summary> /// </summary>
/// <returns>The inverse quaternion.</returns> /// <returns>The inverse quaternion.</returns>
public Quat Inverse() public Quaternion Inverse()
{ {
#if DEBUG #if DEBUG
if (!IsNormalized()) if (!IsNormalized())
{ {
throw new InvalidOperationException("Quat is not normalized"); throw new InvalidOperationException("Quaternion is not normalized");
} }
#endif #endif
return new Quat(-x, -y, -z, w); return new Quaternion(-x, -y, -z, w);
} }
/// <summary> /// <summary>
@ -210,12 +210,12 @@ namespace Godot
/// Returns a copy of the quaternion, normalized to unit length. /// Returns a copy of the quaternion, normalized to unit length.
/// </summary> /// </summary>
/// <returns>The normalized quaternion.</returns> /// <returns>The normalized quaternion.</returns>
public Quat Normalized() public Quaternion Normalized()
{ {
return this / Length; return this / Length;
} }
[Obsolete("Set is deprecated. Use the Quat(" + nameof(real_t) + ", " + nameof(real_t) + ", " + nameof(real_t) + ", " + nameof(real_t) + ") constructor instead.", error: true)] [Obsolete("Set is deprecated. Use the Quaternion(" + nameof(real_t) + ", " + nameof(real_t) + ", " + nameof(real_t) + ", " + nameof(real_t) + ") constructor instead.", error: true)]
public void Set(real_t x, real_t y, real_t z, real_t w) public void Set(real_t x, real_t y, real_t z, real_t w)
{ {
this.x = x; this.x = x;
@ -224,22 +224,22 @@ namespace Godot
this.w = w; this.w = w;
} }
[Obsolete("Set is deprecated. Use the Quat(" + nameof(Quat) + ") constructor instead.", error: true)] [Obsolete("Set is deprecated. Use the Quaternion(" + nameof(Quaternion) + ") constructor instead.", error: true)]
public void Set(Quat q) public void Set(Quaternion q)
{ {
this = q; this = q;
} }
[Obsolete("SetAxisAngle is deprecated. Use the Quat(" + nameof(Vector3) + ", " + nameof(real_t) + ") constructor instead.", error: true)] [Obsolete("SetAxisAngle is deprecated. Use the Quaternion(" + nameof(Vector3) + ", " + nameof(real_t) + ") constructor instead.", error: true)]
public void SetAxisAngle(Vector3 axis, real_t angle) public void SetAxisAngle(Vector3 axis, real_t angle)
{ {
this = new Quat(axis, angle); this = new Quaternion(axis, angle);
} }
[Obsolete("SetEuler is deprecated. Use the Quat(" + nameof(Vector3) + ") constructor instead.", error: true)] [Obsolete("SetEuler is deprecated. Use the Quaternion(" + nameof(Vector3) + ") constructor instead.", error: true)]
public void SetEuler(Vector3 eulerYXZ) public void SetEuler(Vector3 eulerYXZ)
{ {
this = new Quat(eulerYXZ); this = new Quaternion(eulerYXZ);
} }
/// <summary> /// <summary>
@ -251,12 +251,12 @@ namespace Godot
/// <param name="to">The destination quaternion for interpolation. Must be normalized.</param> /// <param name="to">The destination quaternion for interpolation. Must be normalized.</param>
/// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param> /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
/// <returns>The resulting quaternion of the interpolation.</returns> /// <returns>The resulting quaternion of the interpolation.</returns>
public Quat Slerp(Quat to, real_t weight) public Quaternion Slerp(Quaternion to, real_t weight)
{ {
#if DEBUG #if DEBUG
if (!IsNormalized()) if (!IsNormalized())
{ {
throw new InvalidOperationException("Quat is not normalized"); throw new InvalidOperationException("Quaternion is not normalized");
} }
if (!to.IsNormalized()) if (!to.IsNormalized())
{ {
@ -267,7 +267,7 @@ namespace Godot
// Calculate cosine. // Calculate cosine.
real_t cosom = x * to.x + y * to.y + z * to.z + w * to.w; real_t cosom = x * to.x + y * to.y + z * to.z + w * to.w;
var to1 = new Quat(); var to1 = new Quaternion();
// Adjust signs if necessary. // Adjust signs if necessary.
if (cosom < 0.0) if (cosom < 0.0)
@ -299,13 +299,13 @@ namespace Godot
} }
else else
{ {
// Quaternions are very close so we can do a linear interpolation. // Quaternionernions are very close so we can do a linear interpolation.
scale0 = 1.0f - weight; scale0 = 1.0f - weight;
scale1 = weight; scale1 = weight;
} }
// Calculate final values. // Calculate final values.
return new Quat return new Quaternion
( (
(scale0 * x) + (scale1 * to1.x), (scale0 * x) + (scale1 * to1.x),
(scale0 * y) + (scale1 * to1.y), (scale0 * y) + (scale1 * to1.y),
@ -322,7 +322,7 @@ namespace Godot
/// <param name="to">The destination quaternion for interpolation. Must be normalized.</param> /// <param name="to">The destination quaternion for interpolation. Must be normalized.</param>
/// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param> /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
/// <returns>The resulting quaternion of the interpolation.</returns> /// <returns>The resulting quaternion of the interpolation.</returns>
public Quat Slerpni(Quat to, real_t weight) public Quaternion Slerpni(Quaternion to, real_t weight)
{ {
real_t dot = Dot(to); real_t dot = Dot(to);
@ -336,7 +336,7 @@ namespace Godot
real_t newFactor = Mathf.Sin(weight * theta) * sinT; real_t newFactor = Mathf.Sin(weight * theta) * sinT;
real_t invFactor = Mathf.Sin((1.0f - weight) * theta) * sinT; real_t invFactor = Mathf.Sin((1.0f - weight) * theta) * sinT;
return new Quat return new Quaternion
( (
(invFactor * x) + (newFactor * to.x), (invFactor * x) + (newFactor * to.x),
(invFactor * y) + (newFactor * to.y), (invFactor * y) + (newFactor * to.y),
@ -355,7 +355,7 @@ namespace Godot
#if DEBUG #if DEBUG
if (!IsNormalized()) if (!IsNormalized())
{ {
throw new InvalidOperationException("Quat is not normalized"); throw new InvalidOperationException("Quaternion is not normalized");
} }
#endif #endif
var u = new Vector3(x, y, z); var u = new Vector3(x, y, z);
@ -364,24 +364,24 @@ namespace Godot
} }
// Constants // Constants
private static readonly Quat _identity = new Quat(0, 0, 0, 1); private static readonly Quaternion _identity = new Quaternion(0, 0, 0, 1);
/// <summary> /// <summary>
/// The identity quaternion, representing no rotation. /// The identity quaternion, representing no rotation.
/// Equivalent to an identity <see cref="Basis"/> matrix. If a vector is transformed by /// Equivalent to an identity <see cref="Basis"/> matrix. If a vector is transformed by
/// an identity quaternion, it will not change. /// an identity quaternion, it will not change.
/// </summary> /// </summary>
/// <value>Equivalent to <c>new Quat(0, 0, 0, 1)</c>.</value> /// <value>Equivalent to <c>new Quaternion(0, 0, 0, 1)</c>.</value>
public static Quat Identity { get { return _identity; } } public static Quaternion Identity { get { return _identity; } }
/// <summary> /// <summary>
/// Constructs a <see cref="Quat"/> defined by the given values. /// Constructs a <see cref="Quaternion"/> defined by the given values.
/// </summary> /// </summary>
/// <param name="x">X component of the quaternion (imaginary <c>i</c> axis part).</param> /// <param name="x">X component of the quaternion (imaginary <c>i</c> axis part).</param>
/// <param name="y">Y component of the quaternion (imaginary <c>j</c> axis part).</param> /// <param name="y">Y component of the quaternion (imaginary <c>j</c> axis part).</param>
/// <param name="z">Z component of the quaternion (imaginary <c>k</c> axis part).</param> /// <param name="z">Z component of the quaternion (imaginary <c>k</c> axis part).</param>
/// <param name="w">W component of the quaternion (real part).</param> /// <param name="w">W component of the quaternion (real part).</param>
public Quat(real_t x, real_t y, real_t z, real_t w) public Quaternion(real_t x, real_t y, real_t z, real_t w)
{ {
this.x = x; this.x = x;
this.y = y; this.y = y;
@ -390,30 +390,30 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Constructs a <see cref="Quat"/> from the given <see cref="Quat"/>. /// Constructs a <see cref="Quaternion"/> from the given <see cref="Quaternion"/>.
/// </summary> /// </summary>
/// <param name="q">The existing quaternion.</param> /// <param name="q">The existing quaternion.</param>
public Quat(Quat q) public Quaternion(Quaternion q)
{ {
this = q; this = q;
} }
/// <summary> /// <summary>
/// Constructs a <see cref="Quat"/> from the given <see cref="Basis"/>. /// Constructs a <see cref="Quaternion"/> from the given <see cref="Basis"/>.
/// </summary> /// </summary>
/// <param name="basis">The <see cref="Basis"/> to construct from.</param> /// <param name="basis">The <see cref="Basis"/> to construct from.</param>
public Quat(Basis basis) public Quaternion(Basis basis)
{ {
this = basis.Quat(); this = basis.Quaternion();
} }
/// <summary> /// <summary>
/// Constructs a <see cref="Quat"/> that will perform a rotation specified by /// Constructs a <see cref="Quaternion"/> that will perform a rotation specified by
/// Euler angles (in the YXZ convention: when decomposing, first Z, then X, and Y last), /// Euler angles (in the YXZ convention: when decomposing, first Z, then X, and Y last),
/// given in the vector format as (X angle, Y angle, Z angle). /// given in the vector format as (X angle, Y angle, Z angle).
/// </summary> /// </summary>
/// <param name="eulerYXZ">Euler angles that the quaternion will be rotated by.</param> /// <param name="eulerYXZ">Euler angles that the quaternion will be rotated by.</param>
public Quat(Vector3 eulerYXZ) public Quaternion(Vector3 eulerYXZ)
{ {
real_t halfA1 = eulerYXZ.y * 0.5f; real_t halfA1 = eulerYXZ.y * 0.5f;
real_t halfA2 = eulerYXZ.x * 0.5f; real_t halfA2 = eulerYXZ.x * 0.5f;
@ -437,12 +437,12 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Constructs a <see cref="Quat"/> that will rotate around the given axis /// Constructs a <see cref="Quaternion"/> that will rotate around the given axis
/// by the specified angle. The axis must be a normalized vector. /// by the specified angle. The axis must be a normalized vector.
/// </summary> /// </summary>
/// <param name="axis">The axis to rotate around. Must be normalized.</param> /// <param name="axis">The axis to rotate around. Must be normalized.</param>
/// <param name="angle">The angle to rotate, in radians.</param> /// <param name="angle">The angle to rotate, in radians.</param>
public Quat(Vector3 axis, real_t angle) public Quaternion(Vector3 axis, real_t angle)
{ {
#if DEBUG #if DEBUG
if (!axis.IsNormalized()) if (!axis.IsNormalized())
@ -481,9 +481,9 @@ namespace Godot
/// <param name="left">The parent quaternion.</param> /// <param name="left">The parent quaternion.</param>
/// <param name="right">The child quaternion.</param> /// <param name="right">The child quaternion.</param>
/// <returns>The composed quaternion.</returns> /// <returns>The composed quaternion.</returns>
public static Quat operator *(Quat left, Quat right) public static Quaternion operator *(Quaternion left, Quaternion right)
{ {
return new Quat return new Quaternion
( (
(left.w * right.x) + (left.x * right.w) + (left.y * right.z) - (left.z * right.y), (left.w * right.x) + (left.x * right.w) + (left.y * right.z) - (left.z * right.y),
(left.w * right.y) + (left.y * right.w) + (left.z * right.x) - (left.x * right.z), (left.w * right.y) + (left.y * right.w) + (left.z * right.x) - (left.x * right.z),
@ -493,8 +493,8 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Adds each component of the left <see cref="Quat"/> /// Adds each component of the left <see cref="Quaternion"/>
/// to the right <see cref="Quat"/>. This operation is not /// to the right <see cref="Quaternion"/>. This operation is not
/// meaningful on its own, but it can be used as a part of a /// meaningful on its own, but it can be used as a part of a
/// larger expression, such as approximating an intermediate /// larger expression, such as approximating an intermediate
/// rotation between two nearby rotations. /// rotation between two nearby rotations.
@ -502,42 +502,42 @@ namespace Godot
/// <param name="left">The left quaternion to add.</param> /// <param name="left">The left quaternion to add.</param>
/// <param name="right">The right quaternion to add.</param> /// <param name="right">The right quaternion to add.</param>
/// <returns>The added quaternion.</returns> /// <returns>The added quaternion.</returns>
public static Quat operator +(Quat left, Quat right) public static Quaternion operator +(Quaternion left, Quaternion right)
{ {
return new Quat(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); return new Quaternion(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
} }
/// <summary> /// <summary>
/// Subtracts each component of the left <see cref="Quat"/> /// Subtracts each component of the left <see cref="Quaternion"/>
/// by the right <see cref="Quat"/>. This operation is not /// by the right <see cref="Quaternion"/>. This operation is not
/// meaningful on its own, but it can be used as a part of a /// meaningful on its own, but it can be used as a part of a
/// larger expression. /// larger expression.
/// </summary> /// </summary>
/// <param name="left">The left quaternion to subtract.</param> /// <param name="left">The left quaternion to subtract.</param>
/// <param name="right">The right quaternion to subtract.</param> /// <param name="right">The right quaternion to subtract.</param>
/// <returns>The subtracted quaternion.</returns> /// <returns>The subtracted quaternion.</returns>
public static Quat operator -(Quat left, Quat right) public static Quaternion operator -(Quaternion left, Quaternion right)
{ {
return new Quat(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); return new Quaternion(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
} }
/// <summary> /// <summary>
/// Returns the negative value of the <see cref="Quat"/>. /// Returns the negative value of the <see cref="Quaternion"/>.
/// This is the same as writing /// This is the same as writing
/// <c>new Quat(-q.x, -q.y, -q.z, -q.w)</c>. This operation /// <c>new Quaternion(-q.x, -q.y, -q.z, -q.w)</c>. This operation
/// results in a quaternion that represents the same rotation. /// results in a quaternion that represents the same rotation.
/// </summary> /// </summary>
/// <param name="quat">The quaternion to negate.</param> /// <param name="quat">The quaternion to negate.</param>
/// <returns>The negated quaternion.</returns> /// <returns>The negated quaternion.</returns>
public static Quat operator -(Quat quat) public static Quaternion operator -(Quaternion quat)
{ {
return new Quat(-quat.x, -quat.y, -quat.z, -quat.w); return new Quaternion(-quat.x, -quat.y, -quat.z, -quat.w);
} }
[Obsolete("This operator does not have the correct behavior and will be replaced in the future. Do not use this.")] [Obsolete("This operator does not have the correct behavior and will be replaced in the future. Do not use this.")]
public static Quat operator *(Quat left, Vector3 right) public static Quaternion operator *(Quaternion left, Vector3 right)
{ {
return new Quat return new Quaternion
( (
(left.w * right.x) + (left.y * right.z) - (left.z * right.y), (left.w * right.x) + (left.y * right.z) - (left.z * right.y),
(left.w * right.y) + (left.z * right.x) - (left.x * right.z), (left.w * right.y) + (left.z * right.x) - (left.x * right.z),
@ -547,9 +547,9 @@ namespace Godot
} }
[Obsolete("This operator does not have the correct behavior and will be replaced in the future. Do not use this.")] [Obsolete("This operator does not have the correct behavior and will be replaced in the future. Do not use this.")]
public static Quat operator *(Vector3 left, Quat right) public static Quaternion operator *(Vector3 left, Quaternion right)
{ {
return new Quat return new Quaternion
( (
(right.w * left.x) + (right.y * left.z) - (right.z * left.y), (right.w * left.x) + (right.y * left.z) - (right.z * left.y),
(right.w * left.y) + (right.z * left.x) - (right.x * left.z), (right.w * left.y) + (right.z * left.x) - (right.x * left.z),
@ -559,7 +559,7 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Multiplies each component of the <see cref="Quat"/> /// Multiplies each component of the <see cref="Quaternion"/>
/// by the given <see cref="real_t"/>. This operation is not /// by the given <see cref="real_t"/>. This operation is not
/// meaningful on its own, but it can be used as a part of a /// meaningful on its own, but it can be used as a part of a
/// larger expression. /// larger expression.
@ -567,13 +567,13 @@ namespace Godot
/// <param name="left">The quaternion to multiply.</param> /// <param name="left">The quaternion to multiply.</param>
/// <param name="right">The value to multiply by.</param> /// <param name="right">The value to multiply by.</param>
/// <returns>The multiplied quaternion.</returns> /// <returns>The multiplied quaternion.</returns>
public static Quat operator *(Quat left, real_t right) public static Quaternion operator *(Quaternion left, real_t right)
{ {
return new Quat(left.x * right, left.y * right, left.z * right, left.w * right); return new Quaternion(left.x * right, left.y * right, left.z * right, left.w * right);
} }
/// <summary> /// <summary>
/// Multiplies each component of the <see cref="Quat"/> /// Multiplies each component of the <see cref="Quaternion"/>
/// by the given <see cref="real_t"/>. This operation is not /// by the given <see cref="real_t"/>. This operation is not
/// meaningful on its own, but it can be used as a part of a /// meaningful on its own, but it can be used as a part of a
/// larger expression. /// larger expression.
@ -581,13 +581,13 @@ namespace Godot
/// <param name="left">The value to multiply by.</param> /// <param name="left">The value to multiply by.</param>
/// <param name="right">The quaternion to multiply.</param> /// <param name="right">The quaternion to multiply.</param>
/// <returns>The multiplied quaternion.</returns> /// <returns>The multiplied quaternion.</returns>
public static Quat operator *(real_t left, Quat right) public static Quaternion operator *(real_t left, Quaternion right)
{ {
return new Quat(right.x * left, right.y * left, right.z * left, right.w * left); return new Quaternion(right.x * left, right.y * left, right.z * left, right.w * left);
} }
/// <summary> /// <summary>
/// Divides each component of the <see cref="Quat"/> /// Divides each component of the <see cref="Quaternion"/>
/// by the given <see cref="real_t"/>. This operation is not /// by the given <see cref="real_t"/>. This operation is not
/// meaningful on its own, but it can be used as a part of a /// meaningful on its own, but it can be used as a part of a
/// larger expression. /// larger expression.
@ -595,7 +595,7 @@ namespace Godot
/// <param name="left">The quaternion to divide.</param> /// <param name="left">The quaternion to divide.</param>
/// <param name="right">The value to divide by.</param> /// <param name="right">The value to divide by.</param>
/// <returns>The divided quaternion.</returns> /// <returns>The divided quaternion.</returns>
public static Quat operator /(Quat left, real_t right) public static Quaternion operator /(Quaternion left, real_t right)
{ {
return left * (1.0f / right); return left * (1.0f / right);
} }
@ -608,7 +608,7 @@ namespace Godot
/// <param name="left">The left quaternion.</param> /// <param name="left">The left quaternion.</param>
/// <param name="right">The right quaternion.</param> /// <param name="right">The right quaternion.</param>
/// <returns>Whether or not the quaternions are exactly equal.</returns> /// <returns>Whether or not the quaternions are exactly equal.</returns>
public static bool operator ==(Quat left, Quat right) public static bool operator ==(Quaternion left, Quaternion right)
{ {
return left.Equals(right); return left.Equals(right);
} }
@ -621,7 +621,7 @@ namespace Godot
/// <param name="left">The left quaternion.</param> /// <param name="left">The left quaternion.</param>
/// <param name="right">The right quaternion.</param> /// <param name="right">The right quaternion.</param>
/// <returns>Whether or not the quaternions are not equal.</returns> /// <returns>Whether or not the quaternions are not equal.</returns>
public static bool operator !=(Quat left, Quat right) public static bool operator !=(Quaternion left, Quaternion right)
{ {
return !left.Equals(right); return !left.Equals(right);
} }
@ -633,9 +633,9 @@ namespace Godot
/// <returns>Whether or not the quaternion and the other object are exactly equal.</returns> /// <returns>Whether or not the quaternion and the other object are exactly equal.</returns>
public override bool Equals(object obj) public override bool Equals(object obj)
{ {
if (obj is Quat) if (obj is Quaternion)
{ {
return Equals((Quat)obj); return Equals((Quaternion)obj);
} }
return false; return false;
@ -646,7 +646,7 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="other">The other quaternion to compare.</param> /// <param name="other">The other quaternion to compare.</param>
/// <returns>Whether or not the quaternions are exactly equal.</returns> /// <returns>Whether or not the quaternions are exactly equal.</returns>
public bool Equals(Quat other) public bool Equals(Quaternion other)
{ {
return x == other.x && y == other.y && z == other.z && w == other.w; return x == other.x && y == other.y && z == other.z && w == other.w;
} }
@ -657,13 +657,13 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="other">The other quaternion to compare.</param> /// <param name="other">The other quaternion to compare.</param>
/// <returns>Whether or not the quaternions are approximately equal.</returns> /// <returns>Whether or not the quaternions are approximately equal.</returns>
public bool IsEqualApprox(Quat other) public bool IsEqualApprox(Quaternion other)
{ {
return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z) && Mathf.IsEqualApprox(w, other.w); return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z) && Mathf.IsEqualApprox(w, other.w);
} }
/// <summary> /// <summary>
/// Serves as the hash function for <see cref="Quat"/>. /// Serves as the hash function for <see cref="Quaternion"/>.
/// </summary> /// </summary>
/// <returns>A hash code for this quaternion.</returns> /// <returns>A hash code for this quaternion.</returns>
public override int GetHashCode() public override int GetHashCode()
@ -672,7 +672,7 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Converts this <see cref="Quat"/> to a string. /// Converts this <see cref="Quaternion"/> to a string.
/// </summary> /// </summary>
/// <returns>A string representation of this quaternion.</returns> /// <returns>A string representation of this quaternion.</returns>
public override string ToString() public override string ToString()
@ -681,7 +681,7 @@ namespace Godot
} }
/// <summary> /// <summary>
/// Converts this <see cref="Quat"/> to a string with the given <paramref name="format"/>. /// Converts this <see cref="Quaternion"/> to a string with the given <paramref name="format"/>.
/// </summary> /// </summary>
/// <returns>A string representation of this quaternion.</returns> /// <returns>A string representation of this quaternion.</returns>
public string ToString(string format) public string ToString(string format)

10
glue/GodotSharp/GodotSharp/Core/Transform.cs
View File

@ -127,15 +127,15 @@ namespace Godot
/* not sure if very "efficient" but good enough? */ /* not sure if very "efficient" but good enough? */
Vector3 sourceScale = basis.Scale; Vector3 sourceScale = basis.Scale;
Quat sourceRotation = basis.RotationQuat(); Quaternion sourceRotation = basis.RotationQuaternion();
Vector3 sourceLocation = origin; Vector3 sourceLocation = origin;
Vector3 destinationScale = transform.basis.Scale; Vector3 destinationScale = transform.basis.Scale;
Quat destinationRotation = transform.basis.RotationQuat(); Quaternion destinationRotation = transform.basis.RotationQuaternion();
Vector3 destinationLocation = transform.origin; Vector3 destinationLocation = transform.origin;
var interpolated = new Transform(); var interpolated = new Transform();
interpolated.basis.SetQuatScale(sourceRotation.Slerp(destinationRotation, weight).Normalized(), sourceScale.LinearInterpolate(destinationScale, weight)); interpolated.basis.SetQuaternionScale(sourceRotation.Slerp(destinationRotation, weight).Normalized(), sourceScale.LinearInterpolate(destinationScale, weight));
interpolated.origin = sourceLocation.LinearInterpolate(destinationLocation, weight); interpolated.origin = sourceLocation.LinearInterpolate(destinationLocation, weight);
return interpolated; return interpolated;
@ -330,9 +330,9 @@ namespace Godot
/// Constructs a transformation matrix from the given <paramref name="quaternion"/> /// Constructs a transformation matrix from the given <paramref name="quaternion"/>
/// and <paramref name="origin"/> vector. /// and <paramref name="origin"/> vector.
/// </summary> /// </summary>
/// <param name="quaternion">The <see cref="Quat"/> to create the basis from.</param> /// <param name="quaternion">The <see cref="Quaternion"/> to create the basis from.</param>
/// <param name="origin">The origin vector, or column index 3.</param> /// <param name="origin">The origin vector, or column index 3.</param>
public Transform(Quat quaternion, Vector3 origin) public Transform(Quaternion quaternion, Vector3 origin)
{ {
basis = new Basis(quaternion); basis = new Basis(quaternion);
this.origin = origin; this.origin = origin;

2
glue/GodotSharp/GodotSharp/GodotSharp.csproj
View File

@ -44,7 +44,7 @@
<Compile Include="Core\NodePath.cs" /> <Compile Include="Core\NodePath.cs" />
<Compile Include="Core\Object.base.cs" /> <Compile Include="Core\Object.base.cs" />
<Compile Include="Core\Plane.cs" /> <Compile Include="Core\Plane.cs" />
<Compile Include="Core\Quat.cs" /> <Compile Include="Core\Quaternion.cs" />
<Compile Include="Core\Rect2.cs" /> <Compile Include="Core\Rect2.cs" />
<Compile Include="Core\RID.cs" /> <Compile Include="Core\RID.cs" />
<Compile Include="Core\SignalAwaiter.cs" /> <Compile Include="Core\SignalAwaiter.cs" />

6
glue/base_object_glue.cpp
View File

@ -32,7 +32,7 @@
#ifdef MONO_GLUE_ENABLED #ifdef MONO_GLUE_ENABLED
#include "core/reference.h" #include "core/object/reference.h"
#include "core/string_name.h" #include "core/string_name.h"
#include "../csharp_script.h" #include "../csharp_script.h"
@ -68,7 +68,7 @@ void godot_icall_Object_Disposed(MonoObject *p_obj, Object *p_ptr) {
void *data = p_ptr->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index()); void *data = p_ptr->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index());
if (data) { if (data) {
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
if (script_binding.inited) { if (script_binding.inited) {
Ref<MonoGCHandle> &gchandle = script_binding.gchandle; Ref<MonoGCHandle> &gchandle = script_binding.gchandle;
if (gchandle.is_valid()) { if (gchandle.is_valid()) {
@ -115,7 +115,7 @@ void godot_icall_Reference_Disposed(MonoObject *p_obj, Object *p_ptr, MonoBoolea
void *data = ref->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index()); void *data = ref->get_script_instance_binding(CSharpLanguage::get_singleton()->get_language_index());
if (data) { if (data) {
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->get(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->get();
if (script_binding.inited) { if (script_binding.inited) {
Ref<MonoGCHandle> &gchandle = script_binding.gchandle; Ref<MonoGCHandle> &gchandle = script_binding.gchandle;
if (gchandle.is_valid()) { if (gchandle.is_valid()) {

4
glue/base_object_glue.h
View File

@ -33,8 +33,8 @@
#ifdef MONO_GLUE_ENABLED #ifdef MONO_GLUE_ENABLED
#include "core/class_db.h" #include "core/object/class_db.h"
#include "core/object.h" #include "core/object/object.h"
#include "../mono_gd/gd_mono_marshal.h" #include "../mono_gd/gd_mono_marshal.h"

4
glue/gd_glue.cpp
View File

@ -35,8 +35,8 @@
#include "core/array.h" #include "core/array.h"
#include "core/io/marshalls.h" #include "core/io/marshalls.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "core/variant.h" #include "core/variant/variant.h"
#include "core/variant_parser.h" #include "core/variant_parser.h"
#include "../mono_gd/gd_mono_cache.h" #include "../mono_gd/gd_mono_cache.h"

16
glue/glue_header.h
View File

@ -55,16 +55,16 @@ void godot_register_glue_header_icalls() {
// Used by the generated glue // Used by the generated glue
#include "core/array.h" #include "core/variant/array.h"
#include "core/class_db.h" #include "core/object/class_db.h"
#include "core/dictionary.h" #include "core/variant/dictionary.h"
#include "core/engine.h" #include "core/config/engine.h"
#include "core/method_bind.h" #include "core/method_bind.h"
#include "core/node_path.h" #include "core/string/node_path.h"
#include "core/object.h" #include "core/object/object.h"
#include "core/reference.h" #include "core/object/reference.h"
#include "core/typedefs.h" #include "core/typedefs.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "../mono_gd/gd_mono_class.h" #include "../mono_gd/gd_mono_class.h"
#include "../mono_gd/gd_mono_internals.h" #include "../mono_gd/gd_mono_internals.h"

2
glue/nodepath_glue.cpp
View File

@ -32,7 +32,7 @@
#ifdef MONO_GLUE_ENABLED #ifdef MONO_GLUE_ENABLED
#include "core/ustring.h" #include "core/string/ustring.h"
NodePath *godot_icall_NodePath_Ctor(MonoString *p_path) { NodePath *godot_icall_NodePath_Ctor(MonoString *p_path) {
return memnew(NodePath(GDMonoMarshal::mono_string_to_godot(p_path))); return memnew(NodePath(GDMonoMarshal::mono_string_to_godot(p_path)));

2
glue/rid_glue.h
View File

@ -33,7 +33,7 @@
#ifdef MONO_GLUE_ENABLED #ifdef MONO_GLUE_ENABLED
#include "core/object.h" #include "core/object/object.h"
#include "core/rid.h" #include "core/rid.h"
#include "../mono_gd/gd_mono_marshal.h" #include "../mono_gd/gd_mono_marshal.h"

6
glue/string_glue.cpp
View File

@ -32,9 +32,9 @@
#ifdef MONO_GLUE_ENABLED #ifdef MONO_GLUE_ENABLED
#include "core/ustring.h" #include "core/string/ustring.h"
#include "core/variant.h" #include "core/variant/variant.h"
#include "core/vector.h" #include "core/containers/vector.h"
MonoArray *godot_icall_String_md5_buffer(MonoString *p_str) { MonoArray *godot_icall_String_md5_buffer(MonoString *p_str) {
Vector<uint8_t> ret = GDMonoMarshal::mono_string_to_godot(p_str).md5_buffer(); Vector<uint8_t> ret = GDMonoMarshal::mono_string_to_godot(p_str).md5_buffer();

4
godotsharp_dirs.cpp
View File

@ -32,7 +32,7 @@
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "core/version.h" #include "core/version.h"
@ -75,7 +75,7 @@ String _get_mono_user_dir() {
// contain yourself // contain yourself
settings_path = exe_dir.plus_file("editor_data"); settings_path = exe_dir.plus_file("editor_data");
} else { } else {
settings_path = OS::get_singleton()->get_data_path().plus_file(OS::get_singleton()->get_godot_dir_name()); settings_path = OS::get_singleton()->get_data_path().plus_file(OS::get_singleton()->get_pandemonium_dir_name());
} }
return settings_path.plus_file("mono"); return settings_path.plus_file("mono");

2
godotsharp_dirs.h
View File

@ -31,7 +31,7 @@
#ifndef GODOTSHARP_DIRS_H #ifndef GODOTSHARP_DIRS_H
#define GODOTSHARP_DIRS_H #define GODOTSHARP_DIRS_H
#include "core/ustring.h" #include "core/string/ustring.h"
namespace GodotSharpDirs { namespace GodotSharpDirs {

2
mono_gc_handle.h
View File

@ -33,7 +33,7 @@
#include <mono/jit/jit.h> #include <mono/jit/jit.h>
#include "core/reference.h" #include "core/object/reference.h"
class MonoGCHandle : public Reference { class MonoGCHandle : public Reference {
GDCLASS(MonoGCHandle, Reference); GDCLASS(MonoGCHandle, Reference);

2
mono_gd/android_mono_config.h
View File

@ -33,7 +33,7 @@
#ifdef ANDROID_ENABLED #ifdef ANDROID_ENABLED
#include "core/ustring.h" #include "core/string/ustring.h"
// This function is defined in an auto-generated source file // This function is defined in an auto-generated source file
String get_godot_android_mono_config(); String get_godot_android_mono_config();

2
mono_gd/gd_mono.cpp
View File

@ -41,7 +41,7 @@
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/os/thread.h" #include "core/os/thread.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "../csharp_script.h" #include "../csharp_script.h"
#include "../godotsharp_dirs.h" #include "../godotsharp_dirs.h"

10
mono_gd/gd_mono_assembly.cpp
View File

@ -34,10 +34,10 @@
#include <mono/metadata/tokentype.h> #include <mono/metadata/tokentype.h>
#include "core/io/file_access_pack.h" #include "core/io/file_access_pack.h"
#include "core/list.h" #include "core/containers/list.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "../godotsharp_dirs.h" #include "../godotsharp_dirs.h"
#include "gd_mono_cache.h" #include "gd_mono_cache.h"
@ -320,7 +320,7 @@ no_pdb:
void GDMonoAssembly::unload() { void GDMonoAssembly::unload() {
ERR_FAIL_NULL(image); // Should not be called if already unloaded ERR_FAIL_NULL(image); // Should not be called if already unloaded
for (Map<MonoClass *, GDMonoClass *>::Element *E = cached_raw.front(); E; E = E->next()) { for (RBMap<MonoClass *, GDMonoClass *>::Element *E = cached_raw.front(); E; E = E->next()) {
memdelete(E->value()); memdelete(E->value());
} }
@ -361,7 +361,7 @@ GDMonoClass *GDMonoAssembly::get_class(const StringName &p_namespace, const Stri
GDMonoClass *GDMonoAssembly::get_class(MonoClass *p_mono_class) { GDMonoClass *GDMonoAssembly::get_class(MonoClass *p_mono_class) {
ERR_FAIL_NULL_V(image, NULL); ERR_FAIL_NULL_V(image, NULL);
Map<MonoClass *, GDMonoClass *>::Element *match = cached_raw.find(p_mono_class); RBMap<MonoClass *, GDMonoClass *>::Element *match = cached_raw.find(p_mono_class);
if (match) if (match)
return match->value(); return match->value();
@ -381,7 +381,7 @@ GDMonoClass *GDMonoAssembly::get_object_derived_class(const StringName &p_class)
GDMonoClass *match = NULL; GDMonoClass *match = NULL;
if (gdobject_class_cache_updated) { if (gdobject_class_cache_updated) {
Map<StringName, GDMonoClass *>::Element *result = gdobject_class_cache.find(p_class); RBMap<StringName, GDMonoClass *>::Element *result = gdobject_class_cache.find(p_class);
if (result) if (result)
match = result->get(); match = result->get();

10
mono_gd/gd_mono_assembly.h
View File

@ -34,9 +34,9 @@
#include <mono/jit/jit.h> #include <mono/jit/jit.h>
#include <mono/metadata/assembly.h> #include <mono/metadata/assembly.h>
#include "core/hash_map.h" #include "core/containers/hash_map.h"
#include "core/map.h" #include "core/containers/rb_map.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "gd_mono_utils.h" #include "gd_mono_utils.h"
class GDMonoAssembly { class GDMonoAssembly {
@ -76,10 +76,10 @@ class GDMonoAssembly {
#endif #endif
bool gdobject_class_cache_updated; bool gdobject_class_cache_updated;
Map<StringName, GDMonoClass *> gdobject_class_cache; RBMap<StringName, GDMonoClass *> gdobject_class_cache;
HashMap<ClassKey, GDMonoClass *, ClassKey::Hasher> cached_classes; HashMap<ClassKey, GDMonoClass *, ClassKey::Hasher> cached_classes;
Map<MonoClass *, GDMonoClass *> cached_raw; RBMap<MonoClass *, GDMonoClass *> cached_raw;
static Vector<String> search_dirs; static Vector<String> search_dirs;

4
mono_gd/gd_mono_cache.cpp
View File

@ -106,7 +106,7 @@ void CachedData::clear_godot_api_cache() {
class_Transform2D = NULL; class_Transform2D = NULL;
class_Vector3 = NULL; class_Vector3 = NULL;
class_Basis = NULL; class_Basis = NULL;
class_Quat = NULL; class_Quaternion = NULL;
class_Transform = NULL; class_Transform = NULL;
class_AABB = NULL; class_AABB = NULL;
class_Color = NULL; class_Color = NULL;
@ -222,7 +222,7 @@ void update_godot_api_cache() {
CACHE_CLASS_AND_CHECK(Transform2D, GODOT_API_CLASS(Transform2D)); CACHE_CLASS_AND_CHECK(Transform2D, GODOT_API_CLASS(Transform2D));
CACHE_CLASS_AND_CHECK(Vector3, GODOT_API_CLASS(Vector3)); CACHE_CLASS_AND_CHECK(Vector3, GODOT_API_CLASS(Vector3));
CACHE_CLASS_AND_CHECK(Basis, GODOT_API_CLASS(Basis)); CACHE_CLASS_AND_CHECK(Basis, GODOT_API_CLASS(Basis));
CACHE_CLASS_AND_CHECK(Quat, GODOT_API_CLASS(Quat)); CACHE_CLASS_AND_CHECK(Quaternion, GODOT_API_CLASS(Quaternion));
CACHE_CLASS_AND_CHECK(Transform, GODOT_API_CLASS(Transform)); CACHE_CLASS_AND_CHECK(Transform, GODOT_API_CLASS(Transform));
CACHE_CLASS_AND_CHECK(AABB, GODOT_API_CLASS(AABB)); CACHE_CLASS_AND_CHECK(AABB, GODOT_API_CLASS(AABB));
CACHE_CLASS_AND_CHECK(Color, GODOT_API_CLASS(Color)); CACHE_CLASS_AND_CHECK(Color, GODOT_API_CLASS(Color));

2
mono_gd/gd_mono_cache.h
View File

@ -77,7 +77,7 @@ struct CachedData {
GDMonoClass *class_Transform2D; GDMonoClass *class_Transform2D;
GDMonoClass *class_Vector3; GDMonoClass *class_Vector3;
GDMonoClass *class_Basis; GDMonoClass *class_Basis;
GDMonoClass *class_Quat; GDMonoClass *class_Quaternion;
GDMonoClass *class_Transform; GDMonoClass *class_Transform;
GDMonoClass *class_AABB; GDMonoClass *class_AABB;
GDMonoClass *class_Color; GDMonoClass *class_Color;

14
mono_gd/gd_mono_class.cpp
View File

@ -346,7 +346,7 @@ GDMonoMethod *GDMonoClass::get_method_with_desc(const String &p_description, boo
} }
GDMonoField *GDMonoClass::get_field(const StringName &p_name) { GDMonoField *GDMonoClass::get_field(const StringName &p_name) {
Map<StringName, GDMonoField *>::Element *result = fields.find(p_name); RBMap<StringName, GDMonoField *>::Element *result = fields.find(p_name);
if (result) if (result)
return result->value(); return result->value();
@ -375,7 +375,7 @@ const Vector<GDMonoField *> &GDMonoClass::get_all_fields() {
while ((raw_field = mono_class_get_fields(mono_class, &iter)) != NULL) { while ((raw_field = mono_class_get_fields(mono_class, &iter)) != NULL) {
StringName name = String::utf8(mono_field_get_name(raw_field)); StringName name = String::utf8(mono_field_get_name(raw_field));
Map<StringName, GDMonoField *>::Element *match = fields.find(name); RBMap<StringName, GDMonoField *>::Element *match = fields.find(name);
if (match) { if (match) {
fields_list.push_back(match->get()); fields_list.push_back(match->get());
@ -392,7 +392,7 @@ const Vector<GDMonoField *> &GDMonoClass::get_all_fields() {
} }
GDMonoProperty *GDMonoClass::get_property(const StringName &p_name) { GDMonoProperty *GDMonoClass::get_property(const StringName &p_name) {
Map<StringName, GDMonoProperty *>::Element *result = properties.find(p_name); RBMap<StringName, GDMonoProperty *>::Element *result = properties.find(p_name);
if (result) if (result)
return result->value(); return result->value();
@ -421,7 +421,7 @@ const Vector<GDMonoProperty *> &GDMonoClass::get_all_properties() {
while ((raw_property = mono_class_get_properties(mono_class, &iter)) != NULL) { while ((raw_property = mono_class_get_properties(mono_class, &iter)) != NULL) {
StringName name = String::utf8(mono_property_get_name(raw_property)); StringName name = String::utf8(mono_property_get_name(raw_property));
Map<StringName, GDMonoProperty *>::Element *match = properties.find(name); RBMap<StringName, GDMonoProperty *>::Element *match = properties.find(name);
if (match) { if (match) {
properties_list.push_back(match->get()); properties_list.push_back(match->get());
@ -457,7 +457,7 @@ const Vector<GDMonoClass *> &GDMonoClass::get_all_delegates() {
if (mono_class_is_delegate(raw_class)) { if (mono_class_is_delegate(raw_class)) {
StringName name = String::utf8(mono_class_get_name(raw_class)); StringName name = String::utf8(mono_class_get_name(raw_class));
Map<StringName, GDMonoClass *>::Element *match = delegates.find(name); RBMap<StringName, GDMonoClass *>::Element *match = delegates.find(name);
if (match) { if (match) {
delegates_list.push_back(match->get()); delegates_list.push_back(match->get());
@ -509,11 +509,11 @@ GDMonoClass::~GDMonoClass() {
mono_custom_attrs_free(attributes); mono_custom_attrs_free(attributes);
} }
for (Map<StringName, GDMonoField *>::Element *E = fields.front(); E; E = E->next()) { for (RBMap<StringName, GDMonoField *>::Element *E = fields.front(); E; E = E->next()) {
memdelete(E->value()); memdelete(E->value());
} }
for (Map<StringName, GDMonoProperty *>::Element *E = properties.front(); E; E = E->next()) { for (RBMap<StringName, GDMonoProperty *>::Element *E = properties.front(); E; E = E->next()) {
memdelete(E->value()); memdelete(E->value());
} }

10
mono_gd/gd_mono_class.h
View File

@ -31,8 +31,8 @@
#ifndef GD_MONO_CLASS_H #ifndef GD_MONO_CLASS_H
#define GD_MONO_CLASS_H #define GD_MONO_CLASS_H
#include "core/map.h" #include "core/containers/rb_map.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "gd_mono_field.h" #include "gd_mono_field.h"
#include "gd_mono_header.h" #include "gd_mono_header.h"
@ -86,15 +86,15 @@ class GDMonoClass {
Vector<GDMonoMethod *> method_list; Vector<GDMonoMethod *> method_list;
bool fields_fetched; bool fields_fetched;
Map<StringName, GDMonoField *> fields; RBMap<StringName, GDMonoField *> fields;
Vector<GDMonoField *> fields_list; Vector<GDMonoField *> fields_list;
bool properties_fetched; bool properties_fetched;
Map<StringName, GDMonoProperty *> properties; RBMap<StringName, GDMonoProperty *> properties;
Vector<GDMonoProperty *> properties_list; Vector<GDMonoProperty *> properties_list;
bool delegates_fetched; bool delegates_fetched;
Map<StringName, GDMonoClass *> delegates; RBMap<StringName, GDMonoClass *> delegates;
Vector<GDMonoClass *> delegates_list; Vector<GDMonoClass *> delegates_list;
friend class GDMonoAssembly; friend class GDMonoAssembly;

12
mono_gd/gd_mono_field.cpp
View File

@ -124,8 +124,8 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
break; break;
} }
if (tclass == CACHED_CLASS(Quat)) { if (tclass == CACHED_CLASS(Quaternion)) {
GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_value.operator ::Quat()); GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
mono_field_set_value(p_object, mono_field, &from); mono_field_set_value(p_object, mono_field, &from);
break; break;
} }
@ -290,8 +290,8 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane()); GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane());
mono_field_set_value(p_object, mono_field, &from); mono_field_set_value(p_object, mono_field, &from);
} break; } break;
case Variant::QUAT: { case Variant::QUATERNION: {
GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_value.operator ::Quat()); GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
mono_field_set_value(p_object, mono_field, &from); mono_field_set_value(p_object, mono_field, &from);
} break; } break;
case Variant::AABB: { case Variant::AABB: {
@ -314,8 +314,8 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath()); MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
mono_field_set_value(p_object, mono_field, managed); mono_field_set_value(p_object, mono_field, managed);
} break; } break;
case Variant::_RID: { case Variant::RID: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID()); MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator ::RID());
mono_field_set_value(p_object, mono_field, managed); mono_field_set_value(p_object, mono_field, managed);
} break; } break;
case Variant::OBJECT: { case Variant::OBJECT: {

2
mono_gd/gd_mono_internals.h
View File

@ -35,7 +35,7 @@
#include "../utils/macros.h" #include "../utils/macros.h"
#include "core/object.h" #include "core/object/object.h"
namespace GDMonoInternals { namespace GDMonoInternals {
void tie_managed_to_unmanaged(MonoObject *managed, Object *unmanaged); void tie_managed_to_unmanaged(MonoObject *managed, Object *unmanaged);

16
mono_gd/gd_mono_log.cpp
View File

@ -34,6 +34,7 @@
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/string/ustring.h"
#include "../godotsharp_dirs.h" #include "../godotsharp_dirs.h"
#include "../utils/string_utils.h" #include "../utils/string_utils.h"
@ -120,18 +121,25 @@ void GDMonoLog::_delete_old_log_files(const String &p_logs_dir) {
ERR_FAIL_COND(da->list_dir_begin() != OK); ERR_FAIL_COND(da->list_dir_begin() != OK);
String current; String current = da->get_next();
while ((current = da->get_next()).length()) { while (current.length()) {
if (da->current_is_dir()) if (da->current_is_dir()) {
current = da->get_next();
continue; continue;
if (!current.ends_with(".txt")) }
if (!current.ends_with(".txt")) {
current = da->get_next();
continue; continue;
}
uint64_t modified_time = FileAccess::get_modified_time(da->get_current_dir().plus_file(current)); uint64_t modified_time = FileAccess::get_modified_time(da->get_current_dir().plus_file(current));
if (OS::get_singleton()->get_unix_time() - modified_time > MAX_SECS) { if (OS::get_singleton()->get_unix_time() - modified_time > MAX_SECS) {
da->remove(current); da->remove(current);
} }
current = da->get_next();
} }
da->list_dir_end(); da->list_dir_end();

24
mono_gd/gd_mono_marshal.cpp
View File

@ -86,8 +86,8 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type) {
if (vtclass == CACHED_CLASS(Basis)) if (vtclass == CACHED_CLASS(Basis))
return Variant::BASIS; return Variant::BASIS;
if (vtclass == CACHED_CLASS(Quat)) if (vtclass == CACHED_CLASS(Quaternion))
return Variant::QUAT; return Variant::QUATERNION;
if (vtclass == CACHED_CLASS(Transform)) if (vtclass == CACHED_CLASS(Transform))
return Variant::TRANSFORM; return Variant::TRANSFORM;
@ -160,7 +160,7 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type) {
} }
if (CACHED_CLASS(RID) == type_class) { if (CACHED_CLASS(RID) == type_class) {
return Variant::_RID; return Variant::RID;
} }
if (CACHED_CLASS(Dictionary) == type_class) { if (CACHED_CLASS(Dictionary) == type_class) {
@ -506,9 +506,9 @@ MonoObject *variant_to_mono_object(const Variant &p_var) {
GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_var.operator ::Plane()); GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_var.operator ::Plane());
return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Plane), &from); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Plane), &from);
} }
case Variant::QUAT: { case Variant::QUATERNION: {
GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_var.operator ::Quat()); GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_var.operator ::Quaternion());
return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Quat), &from); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Quaternion), &from);
} }
case Variant::AABB: { case Variant::AABB: {
GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_var.operator ::AABB()); GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_var.operator ::AABB());
@ -528,7 +528,7 @@ MonoObject *variant_to_mono_object(const Variant &p_var) {
} }
case Variant::NODE_PATH: case Variant::NODE_PATH:
return GDMonoUtils::create_managed_from(p_var.operator NodePath()); return GDMonoUtils::create_managed_from(p_var.operator NodePath());
case Variant::_RID: case Variant::RID:
return GDMonoUtils::create_managed_from(p_var.operator ::RID()); return GDMonoUtils::create_managed_from(p_var.operator ::RID());
case Variant::OBJECT: case Variant::OBJECT:
return GDMonoUtils::unmanaged_get_managed(p_var.operator Object *()); return GDMonoUtils::unmanaged_get_managed(p_var.operator Object *());
@ -600,7 +600,7 @@ size_t variant_get_managed_unboxed_size(const ManagedType &p_type) {
RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Transform2D);
RETURN_CHECK_FOR_STRUCT(Vector3); RETURN_CHECK_FOR_STRUCT(Vector3);
RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Basis);
RETURN_CHECK_FOR_STRUCT(Quat); RETURN_CHECK_FOR_STRUCT(Quaternion);
RETURN_CHECK_FOR_STRUCT(Transform); RETURN_CHECK_FOR_STRUCT(Transform);
RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(AABB);
RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Color);
@ -700,7 +700,7 @@ void *variant_to_managed_unboxed(const Variant &p_var, const ManagedType &p_type
RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Transform2D);
RETURN_CHECK_FOR_STRUCT(Vector3); RETURN_CHECK_FOR_STRUCT(Vector3);
RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Basis);
RETURN_CHECK_FOR_STRUCT(Quat); RETURN_CHECK_FOR_STRUCT(Quaternion);
RETURN_CHECK_FOR_STRUCT(Transform); RETURN_CHECK_FOR_STRUCT(Transform);
RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(AABB);
RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Color);
@ -840,7 +840,7 @@ MonoObject *variant_to_mono_object(const Variant &p_var, const ManagedType &p_ty
RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Transform2D);
RETURN_CHECK_FOR_STRUCT(Vector3); RETURN_CHECK_FOR_STRUCT(Vector3);
RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Basis);
RETURN_CHECK_FOR_STRUCT(Quat); RETURN_CHECK_FOR_STRUCT(Quaternion);
RETURN_CHECK_FOR_STRUCT(Transform); RETURN_CHECK_FOR_STRUCT(Transform);
RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(AABB);
RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Color);
@ -966,8 +966,8 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type
if (vtclass == CACHED_CLASS(Basis)) if (vtclass == CACHED_CLASS(Basis))
return MARSHALLED_IN(Basis, unbox_addr<GDMonoMarshal::M_Basis>(p_obj)); return MARSHALLED_IN(Basis, unbox_addr<GDMonoMarshal::M_Basis>(p_obj));
if (vtclass == CACHED_CLASS(Quat)) if (vtclass == CACHED_CLASS(Quaternion))
return MARSHALLED_IN(Quat, unbox_addr<GDMonoMarshal::M_Quat>(p_obj)); return MARSHALLED_IN(Quaternion, unbox_addr<GDMonoMarshal::M_Quaternion>(p_obj));
if (vtclass == CACHED_CLASS(Transform)) if (vtclass == CACHED_CLASS(Transform))
return MARSHALLED_IN(Transform, unbox_addr<GDMonoMarshal::M_Transform>(p_obj)); return MARSHALLED_IN(Transform, unbox_addr<GDMonoMarshal::M_Transform>(p_obj));

56
mono_gd/gd_mono_marshal.h
View File

@ -31,7 +31,7 @@
#ifndef GD_MONO_MARSHAL_H #ifndef GD_MONO_MARSHAL_H
#define GD_MONO_MARSHAL_H #define GD_MONO_MARSHAL_H
#include "core/variant.h" #include "core/variant/variant.h"
#include "gd_mono.h" #include "gd_mono.h"
#include "gd_mono_utils.h" #include "gd_mono_utils.h"
@ -91,7 +91,7 @@ _FORCE_INLINE_ MonoString *mono_from_utf8_string(const String &p_string) {
} }
_FORCE_INLINE_ MonoString *mono_from_utf16_string(const String &p_string) { _FORCE_INLINE_ MonoString *mono_from_utf16_string(const String &p_string) {
return mono_string_from_utf16((mono_unichar2 *)p_string.c_str()); return mono_string_from_utf16((mono_unichar2 *)p_string.get_data());
} }
_FORCE_INLINE_ MonoString *mono_string_from_godot(const String &p_string) { _FORCE_INLINE_ MonoString *mono_string_from_godot(const String &p_string) {
@ -228,11 +228,11 @@ enum {
MATCHES_Basis = (MATCHES_Vector3 && (sizeof(Basis) == (sizeof(Vector3) * 3))), // No field offset required, it stores an array MATCHES_Basis = (MATCHES_Vector3 && (sizeof(Basis) == (sizeof(Vector3) * 3))), // No field offset required, it stores an array
MATCHES_Quat = (MATCHES_real_t && (sizeof(Quat) == (sizeof(real_t) * 4)) && MATCHES_Quaternion = (MATCHES_real_t && (sizeof(Quaternion) == (sizeof(real_t) * 4)) &&
offsetof(Quat, x) == (sizeof(real_t) * 0) && offsetof(Quaternion, x) == (sizeof(real_t) * 0) &&
offsetof(Quat, y) == (sizeof(real_t) * 1) && offsetof(Quaternion, y) == (sizeof(real_t) * 1) &&
offsetof(Quat, z) == (sizeof(real_t) * 2) && offsetof(Quaternion, z) == (sizeof(real_t) * 2) &&
offsetof(Quat, w) == (sizeof(real_t) * 3)), offsetof(Quaternion, w) == (sizeof(real_t) * 3)),
MATCHES_Transform = (MATCHES_Basis && MATCHES_Vector3 && (sizeof(Transform) == (sizeof(Basis) + sizeof(Vector3))) && MATCHES_Transform = (MATCHES_Basis && MATCHES_Vector3 && (sizeof(Transform) == (sizeof(Basis) + sizeof(Vector3))) &&
offsetof(Transform, basis) == 0 && offsetof(Transform, basis) == 0 &&
@ -257,7 +257,7 @@ enum {
#ifdef GD_MONO_FORCE_INTEROP_STRUCT_COPY #ifdef GD_MONO_FORCE_INTEROP_STRUCT_COPY
/* clang-format off */ /* clang-format off */
GD_STATIC_ASSERT(MATCHES_Vector2 && MATCHES_Rect2 && MATCHES_Transform2D && MATCHES_Vector3 && GD_STATIC_ASSERT(MATCHES_Vector2 && MATCHES_Rect2 && MATCHES_Transform2D && MATCHES_Vector3 &&
MATCHES_Basis && MATCHES_Quat && MATCHES_Transform && MATCHES_AABB && MATCHES_Color &&MATCHES_Plane); MATCHES_Basis && MATCHES_Quaternion && MATCHES_Transform && MATCHES_AABB && MATCHES_Color &&MATCHES_Plane);
/* clang-format on */ /* clang-format on */
#endif #endif
@ -294,19 +294,19 @@ struct M_Rect2 {
}; };
struct M_Transform2D { struct M_Transform2D {
M_Vector2 elements[3]; M_Vector2 columns[3];
static _FORCE_INLINE_ Transform2D convert_to(const M_Transform2D &p_from) { static _FORCE_INLINE_ Transform2D convert_to(const M_Transform2D &p_from) {
return Transform2D(p_from.elements[0].x, p_from.elements[0].y, return Transform2D(p_from.columns[0].x, p_from.columns[0].y,
p_from.elements[1].x, p_from.elements[1].y, p_from.columns[1].x, p_from.columns[1].y,
p_from.elements[2].x, p_from.elements[2].y); p_from.columns[2].x, p_from.columns[2].y);
} }
static _FORCE_INLINE_ M_Transform2D convert_from(const Transform2D &p_from) { static _FORCE_INLINE_ M_Transform2D convert_from(const Transform2D &p_from) {
M_Transform2D ret = { M_Transform2D ret = {
M_Vector2::convert_from(p_from.elements[0]), M_Vector2::convert_from(p_from.columns[0]),
M_Vector2::convert_from(p_from.elements[1]), M_Vector2::convert_from(p_from.columns[1]),
M_Vector2::convert_from(p_from.elements[2]) M_Vector2::convert_from(p_from.columns[2])
}; };
return ret; return ret;
} }
@ -326,33 +326,33 @@ struct M_Vector3 {
}; };
struct M_Basis { struct M_Basis {
M_Vector3 elements[3]; M_Vector3 rows[3];
static _FORCE_INLINE_ Basis convert_to(const M_Basis &p_from) { static _FORCE_INLINE_ Basis convert_to(const M_Basis &p_from) {
return Basis(M_Vector3::convert_to(p_from.elements[0]), return Basis(M_Vector3::convert_to(p_from.rows[0]),
M_Vector3::convert_to(p_from.elements[1]), M_Vector3::convert_to(p_from.rows[1]),
M_Vector3::convert_to(p_from.elements[2])); M_Vector3::convert_to(p_from.rows[2]));
} }
static _FORCE_INLINE_ M_Basis convert_from(const Basis &p_from) { static _FORCE_INLINE_ M_Basis convert_from(const Basis &p_from) {
M_Basis ret = { M_Basis ret = {
M_Vector3::convert_from(p_from.elements[0]), M_Vector3::convert_from(p_from.rows[0]),
M_Vector3::convert_from(p_from.elements[1]), M_Vector3::convert_from(p_from.rows[1]),
M_Vector3::convert_from(p_from.elements[2]) M_Vector3::convert_from(p_from.rows[2])
}; };
return ret; return ret;
} }
}; };
struct M_Quat { struct M_Quaternion {
real_t x, y, z, w; real_t x, y, z, w;
static _FORCE_INLINE_ Quat convert_to(const M_Quat &p_from) { static _FORCE_INLINE_ Quaternion convert_to(const M_Quaternion &p_from) {
return Quat(p_from.x, p_from.y, p_from.z, p_from.w); return Quaternion(p_from.x, p_from.y, p_from.z, p_from.w);
} }
static _FORCE_INLINE_ M_Quat convert_from(const Quat &p_from) { static _FORCE_INLINE_ M_Quaternion convert_from(const Quaternion &p_from) {
M_Quat ret = { p_from.x, p_from.y, p_from.z, p_from.w }; M_Quaternion ret = { p_from.x, p_from.y, p_from.z, p_from.w };
return ret; return ret;
} }
}; };
@ -454,7 +454,7 @@ DECL_TYPE_MARSHAL_TEMPLATES(Rect2)
DECL_TYPE_MARSHAL_TEMPLATES(Transform2D) DECL_TYPE_MARSHAL_TEMPLATES(Transform2D)
DECL_TYPE_MARSHAL_TEMPLATES(Vector3) DECL_TYPE_MARSHAL_TEMPLATES(Vector3)
DECL_TYPE_MARSHAL_TEMPLATES(Basis) DECL_TYPE_MARSHAL_TEMPLATES(Basis)
DECL_TYPE_MARSHAL_TEMPLATES(Quat) DECL_TYPE_MARSHAL_TEMPLATES(Quaternion)
DECL_TYPE_MARSHAL_TEMPLATES(Transform) DECL_TYPE_MARSHAL_TEMPLATES(Transform)
DECL_TYPE_MARSHAL_TEMPLATES(AABB) DECL_TYPE_MARSHAL_TEMPLATES(AABB)
DECL_TYPE_MARSHAL_TEMPLATES(Color) DECL_TYPE_MARSHAL_TEMPLATES(Color)

6
mono_gd/gd_mono_utils.cpp
View File

@ -35,8 +35,8 @@
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#include "core/reference.h" #include "core/object/reference.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "editor/script_editor_debugger.h" #include "editor/script_editor_debugger.h"
@ -70,7 +70,7 @@ MonoObject *unmanaged_get_managed(Object *unmanaged) {
ERR_FAIL_NULL_V(data, NULL); ERR_FAIL_NULL_V(data, NULL);
CSharpScriptBinding &script_binding = ((Map<Object *, CSharpScriptBinding>::Element *)data)->value(); CSharpScriptBinding &script_binding = ((RBMap<Object *, CSharpScriptBinding>::Element *)data)->value();
if (!script_binding.inited) { if (!script_binding.inited) {
MutexLock lock(CSharpLanguage::get_singleton()->get_language_bind_mutex()); MutexLock lock(CSharpLanguage::get_singleton()->get_language_bind_mutex());

4
mono_gd/gd_mono_utils.h
View File

@ -41,8 +41,8 @@
#include "gd_mono_wasm_m2n.h" #include "gd_mono_wasm_m2n.h"
#endif #endif
#include "core/object.h" #include "core/object/object.h"
#include "core/reference.h" #include "core/object/reference.h"
#define UNHANDLED_EXCEPTION(m_exc) \ #define UNHANDLED_EXCEPTION(m_exc) \
if (unlikely(m_exc != NULL)) { \ if (unlikely(m_exc != NULL)) { \

2
mono_gd/gd_mono_wasm_m2n.cpp
View File

@ -32,7 +32,7 @@
#ifdef JAVASCRIPT_ENABLED #ifdef JAVASCRIPT_ENABLED
#include "core/oa_hash_map.h" #include "core/containers/oa_hash_map.h"
typedef mono_bool (*GodotMonoM2nIcallTrampolineDispatch)(const char *cookie, void *target_func, Mono_InterpMethodArguments *margs); typedef mono_bool (*GodotMonoM2nIcallTrampolineDispatch)(const char *cookie, void *target_func, Mono_InterpMethodArguments *margs);

2
mono_gd/gd_mono_wasm_m2n.h
View File

@ -34,7 +34,7 @@
#ifdef JAVASCRIPT_ENABLED #ifdef JAVASCRIPT_ENABLED
#include "core/typedefs.h" #include "core/typedefs.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include <mono/metadata/loader.h> #include <mono/metadata/loader.h>
#include <mono/utils/mono-publib.h> #include <mono/utils/mono-publib.h>

2
mono_gd/support/android_support.cpp
View File

@ -44,7 +44,7 @@
#endif #endif
#include "core/os/os.h" #include "core/os/os.h"
#include "core/ustring.h" #include "core/string/ustring.h"
#include "platform/android/java_godot_wrapper.h" #include "platform/android/java_godot_wrapper.h"
#include "platform/android/os_android.h" #include "platform/android/os_android.h"
#include "platform/android/thread_jandroid.h" #include "platform/android/thread_jandroid.h"

2
mono_gd/support/android_support.h
View File

@ -33,7 +33,7 @@
#if defined(ANDROID_ENABLED) #if defined(ANDROID_ENABLED)
#include "core/ustring.h" #include "core/string/ustring.h"
namespace gdmono { namespace gdmono {
namespace android { namespace android {

2
mono_gd/support/ios_support.h
View File

@ -33,7 +33,7 @@
#if defined(IPHONE_ENABLED) #if defined(IPHONE_ENABLED)
#include "core/ustring.h" #include "core/string/ustring.h"
namespace gdmono { namespace gdmono {
namespace ios { namespace ios {

2
mono_gd/support/ios_support.mm
View File

@ -35,7 +35,7 @@
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#include <os/log.h> #include <os/log.h>
#include "core/ustring.h" #include "core/string/ustring.h"
#include "../gd_mono_marshal.h" #include "../gd_mono_marshal.h"

16
register_types.cpp
View File

@ -30,7 +30,7 @@
#include "register_types.h" #include "register_types.h"
#include "core/engine.h" #include "core/config/engine.h"
#include "csharp_script.h" #include "csharp_script.h"
@ -40,7 +40,8 @@ Ref<ResourceFormatSaverCSharpScript> resource_saver_cs;
_GodotSharp *_godotsharp = NULL; _GodotSharp *_godotsharp = NULL;
void register_mono_types() { void register_mono_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<CSharpScript>(); ClassDB::register_class<CSharpScript>();
_godotsharp = memnew(_GodotSharp); _godotsharp = memnew(_GodotSharp);
@ -57,13 +58,16 @@ void register_mono_types() {
resource_saver_cs.instance(); resource_saver_cs.instance();
ResourceSaver::add_resource_format_saver(resource_saver_cs); ResourceSaver::add_resource_format_saver(resource_saver_cs);
}
} }
void unregister_mono_types() { void unregister_mono_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ScriptServer::unregister_language(script_language_cs); ScriptServer::unregister_language(script_language_cs);
if (script_language_cs) if (script_language_cs) {
memdelete(script_language_cs); memdelete(script_language_cs);
}
ResourceLoader::remove_resource_format_loader(resource_loader_cs); ResourceLoader::remove_resource_format_loader(resource_loader_cs);
resource_loader_cs.unref(); resource_loader_cs.unref();
@ -71,6 +75,8 @@ void unregister_mono_types() {
ResourceSaver::remove_resource_format_saver(resource_saver_cs); ResourceSaver::remove_resource_format_saver(resource_saver_cs);
resource_saver_cs.unref(); resource_saver_cs.unref();
if (_godotsharp) if (_godotsharp) {
memdelete(_godotsharp); memdelete(_godotsharp);
}
}
} }

11
register_types.h
View File

@ -1,3 +1,6 @@
#ifndef MONO_REGISTER_TYPES_H
#define MONO_REGISTER_TYPES_H
/**************************************************************************/ /**************************************************************************/
/* register_types.h */ /* register_types.h */
/**************************************************************************/ /**************************************************************************/
@ -28,5 +31,9 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/ /**************************************************************************/
void register_mono_types(); #include "modules/register_module_types.h"
void unregister_mono_types();
void register_mono_types(ModuleRegistrationLevel p_level);
void unregister_mono_types(ModuleRegistrationLevel p_level);
#endif

2
signal_awaiter_utils.h
View File

@ -31,7 +31,7 @@
#ifndef SIGNAL_AWAITER_UTILS_H #ifndef SIGNAL_AWAITER_UTILS_H
#define SIGNAL_AWAITER_UTILS_H #define SIGNAL_AWAITER_UTILS_H
#include "core/reference.h" #include "core/object/reference.h"
#include "mono_gc_handle.h" #include "mono_gc_handle.h"
namespace SignalAwaiterUtils { namespace SignalAwaiterUtils {

2
utils/mono_reg_utils.h
View File

@ -33,7 +33,7 @@
#ifdef WINDOWS_ENABLED #ifdef WINDOWS_ENABLED
#include "core/ustring.h" #include "core/string/ustring.h"
struct MonoRegInfo { struct MonoRegInfo {
String version; String version;

2
utils/osx_utils.cpp
View File

@ -32,7 +32,7 @@
#ifdef OSX_ENABLED #ifdef OSX_ENABLED
#include "core/print_string.h" #include "core/string/print_string.h"
#include <CoreFoundation/CoreFoundation.h> #include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h> #include <CoreServices/CoreServices.h>

2
utils/osx_utils.h
View File

@ -28,7 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/ /**************************************************************************/
#include "core/ustring.h" #include "core/string/ustring.h"
#ifndef MONO_OSX_UTILS_H #ifndef MONO_OSX_UTILS_H
#define MONO_OSX_UTILS_H #define MONO_OSX_UTILS_H

2
utils/path_utils.cpp
View File

@ -33,7 +33,7 @@
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
#include "core/os/os.h" #include "core/os/os.h"
#include "core/project_settings.h" #include "core/config/project_settings.h"
#ifdef WINDOWS_ENABLED #ifdef WINDOWS_ENABLED
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN

4
utils/path_utils.h
View File

@ -31,8 +31,8 @@
#ifndef MONO_PATH_UTILS_H #ifndef MONO_PATH_UTILS_H
#define MONO_PATH_UTILS_H #define MONO_PATH_UTILS_H
#include "core/string_builder.h" #include "core/string/string_builder.h"
#include "core/ustring.h" #include "core/string/ustring.h"
namespace path { namespace path {

2
utils/string_utils.cpp
View File

@ -47,7 +47,7 @@ int sfind(const String &p_text, int p_from) {
if (len == 0) if (len == 0)
return -1; return -1;
const CharType *src = p_text.c_str(); const CharType *src = p_text.get_data();
for (int i = p_from; i <= (len - src_len); i++) { for (int i = p_from; i <= (len - src_len); i++) {
bool found = true; bool found = true;

4
utils/string_utils.h
View File

@ -31,8 +31,8 @@
#ifndef MONO_STRING_UTILS_H #ifndef MONO_STRING_UTILS_H
#define MONO_STRING_UTILS_H #define MONO_STRING_UTILS_H
#include "core/ustring.h" #include "core/string/ustring.h"
#include "core/variant.h" #include "core/variant/variant.h"
#include <stdarg.h> #include <stdarg.h>

2
utils/thread_local.cpp
View File

@ -38,7 +38,7 @@
#endif #endif
#include "core/os/memory.h" #include "core/os/memory.h"
#include "core/print_string.h" #include "core/string/print_string.h"
struct ThreadLocalStorage::Impl { struct ThreadLocalStorage::Impl {
#ifdef WINDOWS_ENABLED #ifdef WINDOWS_ENABLED