godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/modules/mono/mono_gd/gd_mono_field.cpp

458 lines
17 KiB
C++
Raw Normal View History

Added mono module
2017-10-02 21:24:00 +00: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 🎆 (cherry picked from commit b5334d14f7a471f94bcbd64d5bae2ad853d0b7f1)
2021-01-01 19:13:46 +00:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
Added mono module
2017-10-02 21:24:00 +00: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-04 23:50:27 +00:00
Added mono module
2017-10-02 21:24:00 +00:00
#include "gd_mono_field.h"
#include <mono/metadata/attrdefs.h>
Mono/C#: WebAssembly support
2019-11-10 16:10:38 +00:00
#include "gd_mono_cache.h"
Added mono module
2017-10-02 21:24:00 +00:00
#include "gd_mono_class.h"
#include "gd_mono_marshal.h"
Mono/C#: WebAssembly support
2019-11-10 16:10:38 +00:00
#include "gd_mono_utils.h"
Added mono module
2017-10-02 21:24:00 +00: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-04 20:05:46 +00:00
void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_value) {
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-02 21:24:00 +00: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-17 19:37:57 +00:00
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
if (tclass == CACHED_CLASS(Quat)) {
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-04 23:19:15 +00:00
GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_value.operator ::Quat());
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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
if (tclass == CACHED_CLASS(Transform)) {
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-04 23:19:15 +00:00
GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_value.operator ::Transform());
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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
break;
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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 01:39:45 +00: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-17 19:37:57 +00:00
}
}
Fix false error when exporting enum in c#
2018-11-05 09:22:15 +00: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-17 19:37:57 +00: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 12:02:19 +00: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 01:39:45 +00:00
ERR_FAIL_MSG("Attempted to set the value of a field of unmarshallable type: '" + tclass->get_name() + "'.");
Added mono module
2017-10-02 21:24:00 +00: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-04 23:19:15 +00:00
case MONO_TYPE_STRING: {
if (p_value.get_type() == Variant::NIL) {
// Otherwise, Variant -> String would return the string "Null"
MonoString *mono_string = NULL;
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-02 21:24:00 +00: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-04 23:19:15 +00: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 (cherry picked from commit 0fec3cb5ed2a009454555440b3853bc4309bc434)
2020-04-22 15:19:45 +00:00
mono_field_set_value(p_object, mono_field, managed);
}
Added mono module
2017-10-02 21:24:00 +00: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-04 23:19:15 +00:00
MonoObject *managed = GDMonoMarshal::variant_to_mono_object_of_class(p_value, type.type_class);
if (likely(managed != nullptr)) {
Add Array and Dictionary wrapper classes to C#
2018-07-18 21:07:57 +00:00
mono_field_set_value(p_object, mono_field, managed);
}
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-04 23:19:15 +00: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-18 21:07:57 +00:00
mono_field_set_value(p_object, mono_field, managed);
}
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00:00
} break;
case Variant::REAL: {
#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-17 19:37:57 +00:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
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-04 23:19:15 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
case Variant::QUAT: {
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-04 23:19:15 +00:00
GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_value.operator ::Quat());
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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
case Variant::TRANSFORM: {
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-04 23:19:15 +00:00
GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_value.operator ::Transform());
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-17 19:37:57 +00: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-04 23:19:15 +00: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-17 19:37:57 +00:00
} break;
Added mono module
2017-10-02 21:24:00 +00:00
case Variant::NODE_PATH: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
Fix set field from MonoObject*
2017-10-22 20:07:52 +00:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 21:24:00 +00:00
} break;
case Variant::_RID: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
Fix set field from MonoObject*
2017-10-22 20:07:52 +00:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 21:24:00 +00:00
} break;
case Variant::OBJECT: {
MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
mono_field_set_value(p_object, mono_field, managed);
break;
}
case Variant::DICTIONARY: {
Add Array and Dictionary wrapper classes to C#
2018-07-18 21:07:57 +00: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-22 20:07:52 +00:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 21:24:00 +00: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-17 19:37:57 +00:00
case Variant::POOL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolByteArray_to_mono_array(p_value.operator ::PoolByteArray());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_INT_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolIntArray_to_mono_array(p_value.operator ::PoolIntArray());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_REAL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolRealArray_to_mono_array(p_value.operator ::PoolRealArray());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolStringArray_to_mono_array(p_value.operator ::PoolStringArray());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolVector2Array_to_mono_array(p_value.operator ::PoolVector2Array());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolVector3Array_to_mono_array(p_value.operator ::PoolVector3Array());
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-17 19:37:57 +00:00
} break;
case Variant::POOL_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-04 23:19:15 +00:00
MonoArray *managed = GDMonoMarshal::PoolColorArray_to_mono_array(p_value.operator ::PoolColorArray());
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-17 19:37:57 +00:00
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine
2021-05-04 12:35:44 +00:00
default:
break;
Added mono module
2017-10-02 21:24:00 +00:00
}
} break;
default: {
Remove duplicate ERR_PRINTS macro
2021-06-16 10:56:25 +00:00
ERR_PRINT("Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding) + ".");
Added mono module
2017-10-02 21:24:00 +00:00
} break;
}
}
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00: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-02 21:24:00 +00: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-08 22:10:54 +00:00
return (bool)GDMonoMarshal::unbox<MonoBoolean>(get_value(p_object));
Added mono module
2017-10-02 21:24:00 +00: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-08 22:10:54 +00:00
return GDMonoMarshal::unbox<int32_t>(get_value(p_object));
Added mono module
2017-10-02 21:24:00 +00: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 02:32:40 +00:00
return GDMonoMarshal::mono_string_to_godot((MonoString *)val);
Added mono module
2017-10-02 21:24:00 +00:00
}
bool GDMonoField::has_attribute(GDMonoClass *p_attr_class) {
ERR_FAIL_NULL_V(p_attr_class, false);
if (!attrs_fetched)
fetch_attributes();
if (!attributes)
return false;
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00:00
return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-02 21:24:00 +00:00
}
MonoObject *GDMonoField::get_attribute(GDMonoClass *p_attr_class) {
ERR_FAIL_NULL_V(p_attr_class, NULL);
if (!attrs_fetched)
fetch_attributes();
if (!attributes)
return NULL;
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00:00
return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-02 21:24:00 +00:00
}
void GDMonoField::fetch_attributes() {
ERR_FAIL_COND(attributes != NULL);
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00:00
attributes = mono_custom_attrs_from_field(owner->get_mono_ptr(), mono_field);
Added mono module
2017-10-02 21:24:00 +00:00
attrs_fetched = true;
}
bool GDMonoField::is_static() {
return mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_STATIC;
}
Mono: Cleanup
2019-01-28 23:02:35 +00:00
IMonoClassMember::Visibility GDMonoField::get_visibility() {
Added mono module
2017-10-02 21:24:00 +00:00
switch (mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_FIELD_ACCESS_MASK) {
case MONO_FIELD_ATTR_PRIVATE:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
return IMonoClassMember::PRIVATE;
Added mono module
2017-10-02 21:24:00 +00:00
case MONO_FIELD_ATTR_FAM_AND_ASSEM:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
return IMonoClassMember::PROTECTED_AND_INTERNAL;
Added mono module
2017-10-02 21:24:00 +00:00
case MONO_FIELD_ATTR_ASSEMBLY:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
return IMonoClassMember::INTERNAL;
Added mono module
2017-10-02 21:24:00 +00:00
case MONO_FIELD_ATTR_FAMILY:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
return IMonoClassMember::PROTECTED;
Added mono module
2017-10-02 21:24:00 +00:00
case MONO_FIELD_ATTR_PUBLIC:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
return IMonoClassMember::PUBLIC;
Added mono module
2017-10-02 21:24:00 +00:00
default:
Mono: Cleanup
2019-01-28 23:02:35 +00:00
ERR_FAIL_V(IMonoClassMember::PRIVATE);
Added mono module
2017-10-02 21:24:00 +00:00
}
}
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00:00
GDMonoField::GDMonoField(MonoClassField *p_mono_field, GDMonoClass *p_owner) {
Added mono module
2017-10-02 21:24:00 +00:00
owner = p_owner;
Mono: Add properties support in scripts
2018-01-04 20:05:46 +00:00
mono_field = p_mono_field;
C # mono supports Unicode code
2021-01-18 08:34:10 +00:00
name = String::utf8(mono_field_get_name(mono_field));
Added mono module
2017-10-02 21:24:00 +00: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;
attributes = NULL;
}
GDMonoField::~GDMonoField() {
if (attributes) {
mono_custom_attrs_free(attributes);
}
}