mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
c9befa63d2
godot/modules/mono/mono_gd/gd_mono_field.cpp

605 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 2019 Happy new year to the wonderful Godot community!
2019-01-01 19:53:14 +08:00
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2019 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>
#include "gd_mono_class.h"
#include "gd_mono_marshal.h"
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) {
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
#define SET_FROM_STRUCT(m_type) \
{ \
GDMonoMarshal::M_##m_type from = MARSHALLED_OUT(m_type, p_value.operator ::m_type()); \
mono_field_set_value(p_object, mono_field, &from); \
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
#define SET_FROM_ARRAY(m_type) \
{ \
MonoArray *managed = GDMonoMarshal::m_type##_to_mono_array(p_value.operator ::m_type()); \
Mono: Fix array field being assigned MonoArray** instead of MonoArray* Fixes #17601
2019-03-06 04:46:44 +08:00
mono_field_set_value(p_object, mono_field, managed); \
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_STRING: {
MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
mono_field_set_value(p_object, mono_field, mono_string);
} 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)) {
SET_FROM_STRUCT(Vector2);
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(Rect2)) {
SET_FROM_STRUCT(Rect2);
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(Transform2D)) {
SET_FROM_STRUCT(Transform2D);
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)) {
SET_FROM_STRUCT(Vector3);
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(Basis)) {
SET_FROM_STRUCT(Basis);
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(Quat)) {
SET_FROM_STRUCT(Quat);
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(Transform)) {
SET_FROM_STRUCT(Transform);
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)) {
SET_FROM_STRUCT(AABB);
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)) {
SET_FROM_STRUCT(Color);
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)) {
SET_FROM_STRUCT(Plane);
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 (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: {
ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed enum value of unmarshallable base type.");
ERR_FAIL();
}
}
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
Added mono module
2017-10-03 05:24:00 +08:00
ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + tclass->get_name());
ERR_FAIL();
} break;
case MONO_TYPE_ARRAY:
case MONO_TYPE_SZARRAY: {
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
MonoArrayType *array_type = mono_type_get_array_type(type.type_class->get_mono_type());
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 (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
SET_FROM_ARRAY(Array);
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 (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
SET_FROM_ARRAY(PoolByteArray);
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 (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
SET_FROM_ARRAY(PoolIntArray);
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 (array_type->eklass == REAL_T_MONOCLASS) {
SET_FROM_ARRAY(PoolRealArray);
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 (array_type->eklass == CACHED_CLASS_RAW(String)) {
SET_FROM_ARRAY(PoolStringArray);
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 (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
SET_FROM_ARRAY(PoolVector2Array);
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 (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
SET_FROM_ARRAY(PoolVector3Array);
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 (array_type->eklass == CACHED_CLASS_RAW(Color)) {
SET_FROM_ARRAY(PoolColorArray);
break;
}
Added mono module
2017-10-03 05:24:00 +08:00
ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed array of unmarshallable element type.");
ERR_FAIL();
} break;
case MONO_TYPE_CLASS: {
GDMonoClass *type_class = type.type_class;
// GodotObject
if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
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;
}
if (CACHED_CLASS(NodePath) == type_class) {
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;
}
if (CACHED_CLASS(RID) == type_class) {
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;
}
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
if (CACHED_CLASS(Dictionary) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (CACHED_CLASS(Array) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
// The order in which we check the following interfaces is very important (dictionaries and generics first)
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 15:44:53 +08:00
MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), type_class->get_mono_type());
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
MonoReflectionType *key_reftype, *value_reftype;
if (GDMonoUtils::Marshal::generic_idictionary_is_assignable_from(reftype, &key_reftype, &value_reftype)) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(),
GDMonoUtils::Marshal::make_generic_dictionary_type(key_reftype, value_reftype));
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
if (type_class->implements_interface(CACHED_CLASS(System_Collections_IDictionary))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
MonoReflectionType *elem_reftype;
if (GDMonoUtils::Marshal::generic_ienumerable_is_assignable_from(reftype, &elem_reftype)) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(),
GDMonoUtils::Marshal::make_generic_array_type(elem_reftype));
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
if (type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 15:44:53 +08:00
if (GDMonoUtils::tools_godot_api_check()) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
} else {
MonoObject *managed = (MonoObject *)GDMonoMarshal::Array_to_mono_array(p_value.operator Array());
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + type_class->get_name());
ERR_FAIL();
} 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;
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-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: {
SET_FROM_STRUCT(Vector2);
} break;
case Variant::RECT2: {
SET_FROM_STRUCT(Rect2);
} break;
case Variant::VECTOR3: {
SET_FROM_STRUCT(Vector3);
} break;
case Variant::TRANSFORM2D: {
SET_FROM_STRUCT(Transform2D);
} break;
case Variant::PLANE: {
SET_FROM_STRUCT(Plane);
} break;
case Variant::QUAT: {
SET_FROM_STRUCT(Quat);
} break;
case Variant::AABB: {
SET_FROM_STRUCT(AABB);
} break;
case Variant::BASIS: {
SET_FROM_STRUCT(Basis);
} break;
case Variant::TRANSFORM: {
SET_FROM_STRUCT(Transform);
} break;
case Variant::COLOR: {
SET_FROM_STRUCT(Color);
} 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;
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);
break;
}
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;
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::POOL_BYTE_ARRAY: {
SET_FROM_ARRAY(PoolByteArray);
} break;
case Variant::POOL_INT_ARRAY: {
SET_FROM_ARRAY(PoolIntArray);
} break;
case Variant::POOL_REAL_ARRAY: {
SET_FROM_ARRAY(PoolRealArray);
} break;
case Variant::POOL_STRING_ARRAY: {
SET_FROM_ARRAY(PoolStringArray);
} break;
case Variant::POOL_VECTOR2_ARRAY: {
SET_FROM_ARRAY(PoolVector2Array);
} break;
case Variant::POOL_VECTOR3_ARRAY: {
SET_FROM_ARRAY(PoolVector3Array);
} break;
case Variant::POOL_COLOR_ARRAY: {
SET_FROM_ARRAY(PoolColorArray);
} break;
Added mono module
2017-10-03 05:24:00 +08:00
default: break;
}
} break;
case MONO_TYPE_GENERICINST: {
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 15:44:53 +08:00
MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), type.type_class->get_mono_type());
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
if (GDMonoUtils::Marshal::type_is_generic_dictionary(reftype)) {
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(), type.type_class);
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
if (GDMonoUtils::Marshal::type_is_generic_array(reftype)) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), type.type_class);
mono_field_set_value(p_object, mono_field, managed);
break;
}
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
// The order in which we check the following interfaces is very important (dictionaries and generics first)
Add Array and Dictionary wrapper classes to C#
2018-07-19 05:07:57 +08:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
MonoReflectionType *key_reftype, *value_reftype;
if (GDMonoUtils::Marshal::generic_idictionary_is_assignable_from(reftype, &key_reftype, &value_reftype)) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(),
GDMonoUtils::Marshal::make_generic_dictionary_type(key_reftype, value_reftype));
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;
}
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
if (type.type_class->implements_interface(CACHED_CLASS(System_Collections_IDictionary))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 10:14:21 +08:00
break;
}
MonoReflectionType *elem_reftype;
if (GDMonoUtils::Marshal::generic_ienumerable_is_assignable_from(reftype, &elem_reftype)) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(),
GDMonoUtils::Marshal::make_generic_array_type(elem_reftype));
mono_field_set_value(p_object, mono_field, managed);
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
break;
}
if (type.type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 15:44:53 +08:00
if (GDMonoUtils::tools_godot_api_check()) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
} else {
MonoObject *managed = (MonoObject *)GDMonoMarshal::Array_to_mono_array(p_value.operator Array());
mono_field_set_value(p_object, mono_field, managed);
break;
}
C#: Add marshalling support for IEnumerable and IDictionary Added constructor that takes IEnumerable for Array and IEnumerable<T> for Array<T>. Added constructor that takes IDictionary for Dictionary and IDictionary<TKey, TValue> for Dictionary<TKey, TValue>.
2019-03-06 01:52:19 +08:00
}
Added mono module
2017-10-03 05:24:00 +08:00
} break;
default: {
ERR_PRINTS(String() + "Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding));
} 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
#undef SET_FROM_ARRAY_AND_BREAK
Added mono module
2017-10-03 05:24:00 +08:00
#undef SET_FROM_STRUCT_AND_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);
if (!attrs_fetched)
fetch_attributes();
if (!attributes)
return false;
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) {
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-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() {
ERR_FAIL_COND(attributes != NULL);
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;
Added mono module
2017-10-03 05:24:00 +08:00
name = mono_field_get_name(mono_field);
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);
}
}
Reference in New Issue Copy Permalink