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

682 lines
23 KiB
C++
Raw Normal View History

Added mono module
2017-10-02 23:24:00 +02:00
/*************************************************************************/
/* gd_mono_field.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
Added mono module
2017-10-02 23:24:00 +02: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 00:50:27 +01:00
Added mono module
2017-10-02 23:24:00 +02:00
#include "gd_mono_field.h"
#include <mono/metadata/attrdefs.h>
Mono/C#: WebAssembly support
2019-11-10 17:10:38 +01:00
#include "gd_mono_cache.h"
Added mono module
2017-10-02 23:24:00 +02:00
#include "gd_mono_class.h"
#include "gd_mono_marshal.h"
Mono/C#: WebAssembly support
2019-11-10 17:10:38 +01:00
#include "gd_mono_utils.h"
Added mono module
2017-10-02 23:24:00 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
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-02 23:24:00 +02: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 21:05:46 +01: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-17 21:37:57 +02: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-02 23:24:00 +02: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 21:37:57 +02: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-05 21:46:44 +01:00
mono_field_set_value(p_object, mono_field, managed); \
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02: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 23:24:00 +02: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 21:37:57 +02:00
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02:00
} break;
case MONO_TYPE_STRING: {
Mono/C#: Fix Variant -> MonoString* when type is Variant:NIL `Variant::operator String()` returns "Null" if the type is `Variant:NIL`. We must consider that and return a null `MonoString*` instead when marshalling. This was also causing a "Null" error to be displayed when exporting a game because null string members would be set to "Null" during hot-reload.
2019-12-19 16:36:49 +01:00
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);
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Vector2)) {
SET_FROM_STRUCT(Vector2);
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
if (tclass == CACHED_CLASS(Vector2i)) {
SET_FROM_STRUCT(Vector2i);
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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Rect2)) {
SET_FROM_STRUCT(Rect2);
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
if (tclass == CACHED_CLASS(Rect2i)) {
SET_FROM_STRUCT(Rect2i);
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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Transform2D)) {
SET_FROM_STRUCT(Transform2D);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Vector3)) {
SET_FROM_STRUCT(Vector3);
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
if (tclass == CACHED_CLASS(Vector3i)) {
SET_FROM_STRUCT(Vector3i);
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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Basis)) {
SET_FROM_STRUCT(Basis);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Quat)) {
SET_FROM_STRUCT(Quat);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Transform)) {
SET_FROM_STRUCT(Transform);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(AABB)) {
SET_FROM_STRUCT(AABB);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Color)) {
SET_FROM_STRUCT(Color);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (tclass == CACHED_CLASS(Plane)) {
SET_FROM_STRUCT(Plane);
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
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-17 21:37:57 +02: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 03:39:45 +02: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 21:37:57 +02:00
}
}
Fix false error when exporting enum in c#
2018-11-05 10:22:15 +01: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 21:37:57 +02: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 14:02:19 +02: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 03:39:45 +02:00
ERR_FAIL_MSG("Attempted to set the value of a field of unmarshallable type: '" + tclass->get_name() + "'.");
Added mono module
2017-10-02 23:24:00 +02:00
} break;
case MONO_TYPE_ARRAY:
case MONO_TYPE_SZARRAY: {
Add Array and Dictionary wrapper classes to C#
2018-07-18 23:07:57 +02:00
MonoArrayType *array_type = mono_type_get_array_type(type.type_class->get_mono_type());
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
SET_FROM_ARRAY(Array);
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
SET_FROM_ARRAY(PackedByteArray);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
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-24 19:20:53 +01:00
SET_FROM_ARRAY(PackedInt32Array);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
if (array_type->eklass == CACHED_CLASS_RAW(int64_t)) {
SET_FROM_ARRAY(PackedInt64Array);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(float)) {
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-24 19:20:53 +01:00
SET_FROM_ARRAY(PackedFloat32Array);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02:00
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
if (array_type->eklass == CACHED_CLASS_RAW(double)) {
SET_FROM_ARRAY(PackedFloat64Array);
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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(String)) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
SET_FROM_ARRAY(PackedStringArray);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
SET_FROM_ARRAY(PackedVector2Array);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
SET_FROM_ARRAY(PackedVector3Array);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
if (array_type->eklass == CACHED_CLASS_RAW(Color)) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
SET_FROM_ARRAY(PackedColorArray);
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 21:37:57 +02:00
break;
}
Added mono module
2017-10-02 23:24:00 +02: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 03:39:45 +02:00
ERR_FAIL_MSG("Attempted to convert Variant to a managed array of unmarshallable element type.");
Added mono module
2017-10-02 23:24:00 +02:00
} 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-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02: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-14 19:20:17 +01:00
if (CACHED_CLASS(StringName) == type_class) {
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-02 23:24:00 +02:00
if (CACHED_CLASS(NodePath) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
Fix set field from MonoObject*
2017-10-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02: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-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02:00
break;
}
Add Array and Dictionary wrapper classes to C#
2018-07-18 23:07:57 +02: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 04:14:21 +02: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 09:44:53 +02: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 04:14:21 +02: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-05 18:52:19 +01: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 04:14:21 +02: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-05 18:52:19 +01:00
if (type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
Mono/C#: WebAssembly support
2019-11-10 17:10:38 +01:00
if (GDMonoCache::tools_godot_api_check()) {
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
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-05 18:52:19 +01: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 03:39:45 +02:00
ERR_FAIL_MSG("Attempted to set the value of a field of unmarshallable type: '" + type_class->get_name() + "'.");
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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-24 19:20:53 +01:00
case Variant::FLOAT: {
Added mono module
2017-10-02 23:24:00 +02: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-17 21:37:57 +02:00
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
Added mono module
2017-10-02 23:24:00 +02: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 21:37:57 +02:00
case Variant::VECTOR2: {
SET_FROM_STRUCT(Vector2);
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
case Variant::VECTOR2I: {
SET_FROM_STRUCT(Vector2i);
} 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 21:37:57 +02:00
case Variant::RECT2: {
SET_FROM_STRUCT(Rect2);
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
case Variant::RECT2I: {
SET_FROM_STRUCT(Rect2i);
} 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 21:37:57 +02:00
case Variant::VECTOR3: {
SET_FROM_STRUCT(Vector3);
} break;
[Mono] Marshaling for Vector2i, Vector3i, and Rect2i
2020-03-03 10:42:20 +01:00
case Variant::VECTOR3I: {
SET_FROM_STRUCT(Vector3i);
} 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 21:37:57 +02:00
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;
Fix C# bindings after recent breaking changes Implementation for new Variant types Callable, Signal, StringName. Added support for PackedInt64Array and PackedFloat64Array. Add generation of signal members as events, as well as support for user created signals as events. NOTE: As of now, raising such events will not emit the signal. As such, one must use `EmitSignal` instead of raising the event directly. Removed old ThreadLocal fallback class. It's safe to use thread_local now since it's supported on all minimum versions of compilers we support.
2020-03-14 19:20:17 +01:00
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-02 23:24:00 +02:00
case Variant::NODE_PATH: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
Fix set field from MonoObject*
2017-10-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02:00
} break;
case Variant::_RID: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
Fix set field from MonoObject*
2017-10-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02: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-14 19:20:17 +01: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-02 23:24:00 +02:00
case Variant::DICTIONARY: {
Add Array and Dictionary wrapper classes to C#
2018-07-18 23:07:57 +02: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 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
case Variant::PACKED_BYTE_ARRAY: {
SET_FROM_ARRAY(PackedByteArray);
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 21:37:57 +02: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-24 19:20:53 +01:00
case Variant::PACKED_INT32_ARRAY: {
SET_FROM_ARRAY(PackedInt32Array);
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 21:37:57 +02: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-14 19:20:17 +01:00
case Variant::PACKED_INT64_ARRAY: {
SET_FROM_ARRAY(PackedInt64Array);
} 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-24 19:20:53 +01:00
case Variant::PACKED_FLOAT32_ARRAY: {
SET_FROM_ARRAY(PackedFloat32Array);
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 21:37:57 +02: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-14 19:20:17 +01:00
case Variant::PACKED_FLOAT64_ARRAY: {
SET_FROM_ARRAY(PackedFloat64Array);
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
case Variant::PACKED_STRING_ARRAY: {
SET_FROM_ARRAY(PackedStringArray);
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 21:37:57 +02:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
case Variant::PACKED_VECTOR2_ARRAY: {
SET_FROM_ARRAY(PackedVector2Array);
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 21:37:57 +02:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
case Variant::PACKED_VECTOR3_ARRAY: {
SET_FROM_ARRAY(PackedVector3Array);
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 21:37:57 +02:00
} break;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
case Variant::PACKED_COLOR_ARRAY: {
SET_FROM_ARRAY(PackedColorArray);
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 21:37:57 +02:00
} break;
Added mono module
2017-10-02 23:24:00 +02: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 09:44:53 +02: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-18 23:07:57 +02:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 04:14:21 +02:00
if (GDMonoUtils::Marshal::type_is_generic_dictionary(reftype)) {
Add Array and Dictionary wrapper classes to C#
2018-07-18 23:07:57 +02: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 04:14:21 +02: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-18 23:07:57 +02:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 04:14:21 +02: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-18 23:07:57 +02:00
C#: Marshalling support for IEnumerable<> and IDictionary<,> Also fixed the hint string of exported members.
2019-05-18 04:14:21 +02: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-22 22:07:52 +02:00
mono_field_set_value(p_object, mono_field, managed);
Added mono module
2017-10-02 23:24:00 +02: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-05 18:52:19 +01: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 04:14:21 +02: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-05 18:52:19 +01:00
break;
}
if (type.type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
Mono/C#: WebAssembly support
2019-11-10 17:10:38 +01:00
if (GDMonoCache::tools_godot_api_check()) {
Re-write mono module editor code in C# Make the build system automatically build the C# Api assemblies to be shipped with the editor. Make the editor, editor player and debug export templates use Api assemblies built with debug symbols. Always run MSBuild to build the editor tools and Api assemblies when building Godot. Several bugs fixed related to assembly hot reloading and restoring state. Fix StringExtensions internal calls not being registered correctly, resulting in MissingMethodException.
2019-07-03 09:44:53 +02:00
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-05 18:52:19 +01:00
}
Added mono module
2017-10-02 23:24:00 +02:00
} break;
default: {
Remove duplicate ERR_PRINT macro.
2019-11-06 17:03:04 +01: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 23:24:00 +02: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 21:37:57 +02:00
#undef SET_FROM_ARRAY_AND_BREAK
Added mono module
2017-10-02 23:24:00 +02:00
#undef SET_FROM_STRUCT_AND_BREAK
}
Mono: Add properties support in scripts
2018-01-04 21:05:46 +01: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 23:24:00 +02: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 00:10:54 +02:00
return (bool)GDMonoMarshal::unbox<MonoBoolean>(get_value(p_object));
Added mono module
2017-10-02 23:24:00 +02: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 00:10:54 +02:00
return GDMonoMarshal::unbox<int32_t>(get_value(p_object));
Added mono module
2017-10-02 23:24:00 +02: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 03:32:40 +01:00
return GDMonoMarshal::mono_string_to_godot((MonoString *)val);
Added mono module
2017-10-02 23:24:00 +02: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 21:05:46 +01:00
return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-02 23:24:00 +02: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 21:05:46 +01:00
return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr());
Added mono module
2017-10-02 23:24:00 +02:00
}
void GDMonoField::fetch_attributes() {
ERR_FAIL_COND(attributes != NULL);
Mono: Add properties support in scripts
2018-01-04 21:05:46 +01:00
attributes = mono_custom_attrs_from_field(owner->get_mono_ptr(), mono_field);
Added mono module
2017-10-02 23:24:00 +02:00
attrs_fetched = true;
}
bool GDMonoField::is_static() {
return mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_STATIC;
}
Mono: Cleanup
2019-01-29 00:02:35 +01:00
IMonoClassMember::Visibility GDMonoField::get_visibility() {
Added mono module
2017-10-02 23:24:00 +02:00
switch (mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_FIELD_ACCESS_MASK) {
case MONO_FIELD_ATTR_PRIVATE:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
return IMonoClassMember::PRIVATE;
Added mono module
2017-10-02 23:24:00 +02:00
case MONO_FIELD_ATTR_FAM_AND_ASSEM:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
return IMonoClassMember::PROTECTED_AND_INTERNAL;
Added mono module
2017-10-02 23:24:00 +02:00
case MONO_FIELD_ATTR_ASSEMBLY:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
return IMonoClassMember::INTERNAL;
Added mono module
2017-10-02 23:24:00 +02:00
case MONO_FIELD_ATTR_FAMILY:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
return IMonoClassMember::PROTECTED;
Added mono module
2017-10-02 23:24:00 +02:00
case MONO_FIELD_ATTR_PUBLIC:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
return IMonoClassMember::PUBLIC;
Added mono module
2017-10-02 23:24:00 +02:00
default:
Mono: Cleanup
2019-01-29 00:02:35 +01:00
ERR_FAIL_V(IMonoClassMember::PRIVATE);
Added mono module
2017-10-02 23:24:00 +02:00
}
}
Mono: Add properties support in scripts
2018-01-04 21:05:46 +01:00
GDMonoField::GDMonoField(MonoClassField *p_mono_field, GDMonoClass *p_owner) {
Added mono module
2017-10-02 23:24:00 +02:00
owner = p_owner;
Mono: Add properties support in scripts
2018-01-04 21:05:46 +01:00
mono_field = p_mono_field;
Added mono module
2017-10-02 23:24:00 +02: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 a new issue Copy permalink