mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-21 10:25:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
41ce417847
godot/modules/mono/mono_gd/gd_mono_field.cpp

527 lines
20 KiB
C++
Raw Normal View History

Added mono module
2017-10-03 05:24:00 +08:00
/*************************************************************************/
/* gd_mono_field.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-02 03:13:46 +08:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
Added mono module
2017-10-03 05:24:00 +08:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 07:50:27 +08:00
Added mono module
2017-10-03 05:24:00 +08:00
#include "gd_mono_field.h"
#include <mono/metadata/attrdefs.h>
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
#include "gd_mono_cache.h"
Added mono module
2017-10-03 05:24:00 +08:00
#include "gd_mono_class.h"
#include "gd_mono_marshal.h"
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
#include "gd_mono_utils.h"
Added mono module
2017-10-03 05:24:00 +08:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
void GDMonoField::set_value(MonoObject *p_object, MonoObject *p_value) {
mono_field_set_value(p_object, mono_field, p_value);
}
Added mono module
2017-10-03 05:24:00 +08:00
void GDMonoField::set_value_raw(MonoObject *p_object, void *p_ptr) {
mono_field_set_value(p_object, mono_field, &p_ptr);
}
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_value) {
Added mono module
2017-10-03 05:24:00 +08:00
switch (type.type_encoding) {
case MONO_TYPE_BOOLEAN: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_CHAR: {
int16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_I1: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_I2: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_I4: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_I8: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_U1: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_U2: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_U4: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_U8: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_R4: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_R8: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_VALUETYPE: {
GDMonoClass *tclass = type.type_class;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Vector2)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_value.operator ::Vector2());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
if (tclass == CACHED_CLASS(Vector2i)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_value.operator ::Vector2i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
break;
}
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Rect2)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_value.operator ::Rect2());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
if (tclass == CACHED_CLASS(Rect2i)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_value.operator ::Rect2i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
break;
}
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Transform2D)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_value.operator ::Transform2D());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Vector3)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_value.operator ::Vector3());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
if (tclass == CACHED_CLASS(Vector3i)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_value.operator ::Vector3i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
break;
}
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Basis)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_value.operator ::Basis());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
Rename Quat to Quaternion
2021-01-20 15:02:02 +08:00
if (tclass == CACHED_CLASS(Quaternion)) {
GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
Rename Transform to Transform3D in core
2020-10-17 13:08:21 +08:00
if (tclass == CACHED_CLASS(Transform3D)) {
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 15:36:08 +08:00
GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(AABB)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_value.operator ::AABB());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Color)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_value.operator ::Color());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (tclass == CACHED_CLASS(Plane)) {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
if (tclass == CACHED_CLASS(Callable)) {
GDMonoMarshal::M_Callable val = GDMonoMarshal::callable_to_managed(p_value.operator Callable());
mono_field_set_value(p_object, mono_field, &val);
break;
}
if (tclass == CACHED_CLASS(SignalInfo)) {
GDMonoMarshal::M_SignalInfo val = GDMonoMarshal::signal_info_to_managed(p_value.operator Signal());
mono_field_set_value(p_object, mono_field, &val);
break;
}
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
if (mono_class_is_enum(tclass->get_mono_ptr())) {
MonoType *enum_basetype = mono_class_enum_basetype(tclass->get_mono_ptr());
switch (mono_type_get_type(enum_basetype)) {
case MONO_TYPE_BOOLEAN: {
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_CHAR: {
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I1: {
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I2: {
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I4: {
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I8: {
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U1: {
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U2: {
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U4: {
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U8: {
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
break;
}
default: {
Replace 'ERR_EXPLAIN' with 'ERR_FAIL_*_MSG' in 'modules/mono' And 'CRASH_*_MSG' as well. Also make error messages puntuation and quotation more consistent.
2019-08-09 09:39:45 +08:00
ERR_FAIL_MSG("Attempted to convert Variant to a managed enum value of unmarshallable base type.");
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
}
}
Fix false error when exporting enum in c#
2018-11-05 17:22:15 +08:00
break;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
}
Export attribute fixes and improvements - Allow non-public fields to be exported as well (to avoid confusion). - Set PROPERTY_HINT_RESOURCE_TYPE for resource derived fields. - Support enums and automatically fill PROPERTY_HINT_ENUM's hint_string for enum fields.
2017-10-17 20:02:19 +08:00
Replace 'ERR_EXPLAIN' with 'ERR_FAIL_*_MSG' in 'modules/mono' And 'CRASH_*_MSG' as well. Also make error messages puntuation and quotation more consistent.
2019-08-09 09:39:45 +08:00
ERR_FAIL_MSG("Attempted to set the value of a field of unmarshallable type: '" + tclass->get_name() + "'.");
Added mono module
2017-10-03 05:24:00 +08:00
} break;
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
case MONO_TYPE_STRING: {
if (p_value.get_type() == Variant::NIL) {
// Otherwise, Variant -> String would return the string "Null"
MonoString *mono_string = nullptr;
mono_field_set_value(p_object, mono_field, mono_string);
} else {
MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
mono_field_set_value(p_object, mono_field, mono_string);
}
} break;
Added mono module
2017-10-03 05:24:00 +08:00
case MONO_TYPE_ARRAY:
case MONO_TYPE_SZARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::variant_to_mono_array(p_value, type.type_class);
if (likely(managed != nullptr)) {
Mono/C#: Allow exporting System.Array of type Godot.Object
2020-04-22 23:19:45 +08:00
mono_field_set_value(p_object, mono_field, managed);
}
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_CLASS: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoObject *managed = GDMonoMarshal::variant_to_mono_object_of_class(p_value, type.type_class);
if (likely(managed != nullptr)) {
Fix set field from MonoObject*
2017-10-23 04:07:52 +08:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-03 05:24:00 +08:00
}
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
} break;
case MONO_TYPE_GENERICINST: {
MonoObject *managed = GDMonoMarshal::variant_to_mono_object_of_genericinst(p_value, type.type_class);
if (likely(managed != nullptr)) {
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
mono_field_set_value(p_object, mono_field, managed);
}
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case MONO_TYPE_OBJECT: {
// Variant
switch (p_value.get_type()) {
case Variant::BOOL: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case Variant::INT: {
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-25 02:20:53 +08:00
case Variant::FLOAT: {
Added mono module
2017-10-03 05:24:00 +08:00
#ifdef REAL_T_IS_DOUBLE
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
#else
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-03 05:24:00 +08:00
#endif
} break;
case Variant::STRING: {
MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
mono_field_set_value(p_object, mono_field, mono_string);
} break;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
case Variant::VECTOR2: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_value.operator ::Vector2());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
case Variant::VECTOR2I: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_value.operator ::Vector2i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
} break;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
case Variant::RECT2: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_value.operator ::Rect2());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
case Variant::RECT2I: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_value.operator ::Rect2i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
} break;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
case Variant::VECTOR3: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_value.operator ::Vector3());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
case Variant::VECTOR3I: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_value.operator ::Vector3i());
mono_field_set_value(p_object, mono_field, &from);
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 17:42:20 +08:00
} break;
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
case Variant::TRANSFORM2D: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_value.operator ::Transform2D());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
case Variant::PLANE: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Rename Quat to Quaternion
2021-01-20 15:02:02 +08:00
case Variant::QUATERNION: {
GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
case Variant::AABB: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_value.operator ::AABB());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
case Variant::BASIS: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_value.operator ::Basis());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 15:36:08 +08:00
case Variant::TRANSFORM3D: {
GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
case Variant::COLOR: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_value.operator ::Color());
mono_field_set_value(p_object, mono_field, &from);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
case Variant::STRING_NAME: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator StringName());
mono_field_set_value(p_object, mono_field, managed);
} break;
Added mono module
2017-10-03 05:24:00 +08:00
case Variant::NODE_PATH: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
Fix set field from MonoObject*
2017-10-23 04:07:52 +08:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 21:53:05 +08:00
case Variant::RID: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator ::RID());
Fix set field from MonoObject*
2017-10-23 04:07:52 +08:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
case Variant::OBJECT: {
MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
mono_field_set_value(p_object, mono_field, managed);
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
} break;
case Variant::CALLABLE: {
GDMonoMarshal::M_Callable val = GDMonoMarshal::callable_to_managed(p_value.operator Callable());
mono_field_set_value(p_object, mono_field, &val);
} break;
case Variant::SIGNAL: {
GDMonoMarshal::M_SignalInfo val = GDMonoMarshal::signal_info_to_managed(p_value.operator Signal());
mono_field_set_value(p_object, mono_field, &val);
} break;
Added mono module
2017-10-03 05:24:00 +08:00
case Variant::DICTIONARY: {
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
} break;
case Variant::ARRAY: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
Fix set field from MonoObject*
2017-10-23 04:07:52 +08:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-03 05:24:00 +08:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
case Variant::PACKED_BYTE_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedByteArray_to_mono_array(p_value.operator ::PackedByteArray());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-25 02:20:53 +08:00
case Variant::PACKED_INT32_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedInt32Array_to_mono_array(p_value.operator ::PackedInt32Array());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
case Variant::PACKED_INT64_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedInt64Array_to_mono_array(p_value.operator ::PackedInt64Array());
mono_field_set_value(p_object, mono_field, managed);
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
} break;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-25 02:20:53 +08:00
case Variant::PACKED_FLOAT32_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedFloat32Array_to_mono_array(p_value.operator ::PackedFloat32Array());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
case Variant::PACKED_FLOAT64_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedFloat64Array_to_mono_array(p_value.operator ::PackedFloat64Array());
mono_field_set_value(p_object, mono_field, managed);
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-15 02:20:17 +08:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
case Variant::PACKED_STRING_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedStringArray_to_mono_array(p_value.operator ::PackedStringArray());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
case Variant::PACKED_VECTOR2_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedVector2Array_to_mono_array(p_value.operator ::PackedVector2Array());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
case Variant::PACKED_VECTOR3_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedVector3Array_to_mono_array(p_value.operator ::PackedVector3Array());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
case Variant::PACKED_COLOR_ARRAY: {
Don't box params on Native->C# calls with Variant params Godot uses Variant parameters for calls to script methods. Up until now we were boxing such parameters when marshalling them for invokation, even if they were value types. Now Godot allocates the marshalled parameters on the stack, reducing the GC allocations resulted from boxing.
2020-12-05 07:19:15 +08:00
MonoArray *managed = GDMonoMarshal::PackedColorArray_to_mono_array(p_value.operator ::PackedColorArray());
mono_field_set_value(p_object, mono_field, managed);
C#: Optimize struct marshalling - We no longer box struct to return them from internal calls. - Use reinterpret_cast if the managed struct layout is the same as the native struct.
2018-10-18 03:37:57 +08:00
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 19:00:47 +08:00
default:
break;
Added mono module
2017-10-03 05:24:00 +08:00
}
} break;
default: {
Remove duplicate ERR_PRINT macro.
2019-11-07 00:03:04 +08:00
ERR_PRINT("Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding) + ".");
Added mono module
2017-10-03 05:24:00 +08:00
} break;
}
}
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
MonoObject *GDMonoField::get_value(MonoObject *p_object) {
return mono_field_get_value_object(mono_domain_get(), mono_field, p_object);
}
Added mono module
2017-10-03 05:24:00 +08:00
bool GDMonoField::get_bool_value(MonoObject *p_object) {
Fixed IntPtr unboxing (#11949) - Fix boolean never reset to false - Fix IntPtr unboxing and cleanup
2017-10-09 06:10:54 +08:00
return (bool)GDMonoMarshal::unbox<MonoBoolean>(get_value(p_object));
Added mono module
2017-10-03 05:24:00 +08:00
}
int GDMonoField::get_int_value(MonoObject *p_object) {
Fixed IntPtr unboxing (#11949) - Fix boolean never reset to false - Fix IntPtr unboxing and cleanup
2017-10-09 06:10:54 +08:00
return GDMonoMarshal::unbox<int32_t>(get_value(p_object));
Added mono module
2017-10-03 05:24:00 +08:00
}
String GDMonoField::get_string_value(MonoObject *p_object) {
MonoObject *val = get_value(p_object);
Marshal NULL MonoString* as empty Godot string
2017-12-24 10:32:40 +08:00
return GDMonoMarshal::mono_string_to_godot((MonoString *)val);
Added mono module
2017-10-03 05:24:00 +08:00
}
bool GDMonoField::has_attribute(GDMonoClass *p_attr_class) {
ERR_FAIL_NULL_V(p_attr_class, false);
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
if (!attrs_fetched) {
Added mono module
2017-10-03 05:24:00 +08:00
fetch_attributes();
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
if (!attributes) {
Added mono module
2017-10-03 05:24:00 +08:00
return false;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-03 05:24:00 +08:00
}
MonoObject *GDMonoField::get_attribute(GDMonoClass *p_attr_class) {
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
ERR_FAIL_NULL_V(p_attr_class, nullptr);
Added mono module
2017-10-03 05:24:00 +08:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
if (!attrs_fetched) {
Added mono module
2017-10-03 05:24:00 +08:00
fetch_attributes();
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
if (!attributes) {
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
return nullptr;
Mono/C#: Fix several clang-tidy warnings and cleanup
2020-07-06 01:19:36 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-03 05:24:00 +08:00
}
void GDMonoField::fetch_attributes() {
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
ERR_FAIL_COND(attributes != nullptr);
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
attributes = mono_custom_attrs_from_field(owner->get_mono_ptr(), mono_field);
Added mono module
2017-10-03 05:24:00 +08:00
attrs_fetched = true;
}
bool GDMonoField::is_static() {
return mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_STATIC;
}
Mono: Cleanup
2019-01-29 07:02:35 +08:00
IMonoClassMember::Visibility GDMonoField::get_visibility() {
Added mono module
2017-10-03 05:24:00 +08:00
switch (mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_FIELD_ACCESS_MASK) {
case MONO_FIELD_ATTR_PRIVATE:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
return IMonoClassMember::PRIVATE;
Added mono module
2017-10-03 05:24:00 +08:00
case MONO_FIELD_ATTR_FAM_AND_ASSEM:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
return IMonoClassMember::PROTECTED_AND_INTERNAL;
Added mono module
2017-10-03 05:24:00 +08:00
case MONO_FIELD_ATTR_ASSEMBLY:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
return IMonoClassMember::INTERNAL;
Added mono module
2017-10-03 05:24:00 +08:00
case MONO_FIELD_ATTR_FAMILY:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
return IMonoClassMember::PROTECTED;
Added mono module
2017-10-03 05:24:00 +08:00
case MONO_FIELD_ATTR_PUBLIC:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
return IMonoClassMember::PUBLIC;
Added mono module
2017-10-03 05:24:00 +08:00
default:
Mono: Cleanup
2019-01-29 07:02:35 +08:00
ERR_FAIL_V(IMonoClassMember::PRIVATE);
Added mono module
2017-10-03 05:24:00 +08:00
}
}
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
GDMonoField::GDMonoField(MonoClassField *p_mono_field, GDMonoClass *p_owner) {
Added mono module
2017-10-03 05:24:00 +08:00
owner = p_owner;
Mono: Add properties support in scripts
2018-01-05 04:05:46 +08:00
mono_field = p_mono_field;
C # mono supports Unicode code
2021-01-18 16:34:10 +08:00
name = String::utf8(mono_field_get_name(mono_field));
Added mono module
2017-10-03 05:24:00 +08:00
MonoType *field_type = mono_field_get_type(mono_field);
type.type_encoding = mono_type_get_type(field_type);
MonoClass *field_type_class = mono_class_from_mono_type(field_type);
type.type_class = GDMono::get_singleton()->get_class(field_type_class);
attrs_fetched = false;
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
attributes = nullptr;
Added mono module
2017-10-03 05:24:00 +08:00
}
GDMonoField::~GDMonoField() {
if (attributes) {
mono_custom_attrs_free(attributes);
}
}
Reference in New Issue Copy Permalink