Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type) { switch (p_type.type_encoding) { case MONO_TYPE_BOOLEAN: return (bool)unbox<MonoBoolean>(p_obj); case MONO_TYPE_I1: return unbox<int8_t>(p_obj); case MONO_TYPE_I2: return unbox<int16_t>(p_obj); case MONO_TYPE_I4: return unbox<int32_t>(p_obj); case MONO_TYPE_I8: return unbox<int64_t>(p_obj); case MONO_TYPE_U1: return unbox<uint8_t>(p_obj); case MONO_TYPE_U2: return unbox<uint16_t>(p_obj); case MONO_TYPE_U4: return unbox<uint32_t>(p_obj); case MONO_TYPE_U8: return unbox<uint64_t>(p_obj); case MONO_TYPE_R4: return unbox<float>(p_obj); case MONO_TYPE_R8: return unbox<double>(p_obj); case MONO_TYPE_STRING: { String str = mono_string_to_godot((MonoString *)p_obj); return str; } break; case MONO_TYPE_VALUETYPE: { GDMonoClass *tclass = p_type.type_class; if (tclass == CACHED_CLASS(Vector2)) RETURN_UNBOXED_STRUCT(Vector2, p_obj); if (tclass == CACHED_CLASS(Rect2)) RETURN_UNBOXED_STRUCT(Rect2, p_obj); if (tclass == CACHED_CLASS(Transform2D)) RETURN_UNBOXED_STRUCT(Transform2D, p_obj); if (tclass == CACHED_CLASS(Vector3)) RETURN_UNBOXED_STRUCT(Vector3, p_obj); if (tclass == CACHED_CLASS(Basis)) RETURN_UNBOXED_STRUCT(Basis, p_obj); if (tclass == CACHED_CLASS(Quat)) RETURN_UNBOXED_STRUCT(Quat, p_obj); if (tclass == CACHED_CLASS(Transform)) RETURN_UNBOXED_STRUCT(Transform, p_obj); if (tclass == CACHED_CLASS(Rect3)) RETURN_UNBOXED_STRUCT(Rect3, p_obj); if (tclass == CACHED_CLASS(Color)) RETURN_UNBOXED_STRUCT(Color, p_obj); if (tclass == CACHED_CLASS(Plane)) RETURN_UNBOXED_STRUCT(Plane, p_obj); if (mono_class_is_enum(tclass->get_raw())) return unbox<int32_t>(p_obj); } break; case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: { MonoArrayType *array_type = mono_type_get_array_type(GDMonoClass::get_raw_type(p_type.type_class)); if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) return mono_array_to_Array((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) return mono_array_to_PoolByteArray((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) return mono_array_to_PoolIntArray((MonoArray *)p_obj); if (array_type->eklass == REAL_T_MONOCLASS) return mono_array_to_PoolRealArray((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(String)) return mono_array_to_PoolStringArray((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) return mono_array_to_PoolVector2Array((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) return mono_array_to_PoolVector3Array((MonoArray *)p_obj); if (array_type->eklass == CACHED_CLASS_RAW(Color)) return mono_array_to_PoolColorArray((MonoArray *)p_obj); ERR_EXPLAIN(String() + "Attempted to convert a managed array of unmarshallable element type to Variant."); ERR_FAIL_V(Variant()); } break; case MONO_TYPE_CLASS: { GDMonoClass *type_class = p_type.type_class; // GodotObject if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) { Object *ptr = unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_obj)); return ptr ? Variant(ptr) : Variant(); } if (CACHED_CLASS(NodePath) == type_class) { NodePath *ptr = unbox<NodePath *>(CACHED_FIELD(NodePath, ptr)->get_value(p_obj)); return ptr ? Variant(*ptr) : Variant(); } if (CACHED_CLASS(RID) == type_class) { RID *ptr = unbox<RID *>(CACHED_FIELD(RID, ptr)->get_value(p_obj)); return ptr ? Variant(*ptr) : Variant(); } } break; case MONO_TYPE_GENERICINST: { if (CACHED_RAW_MONO_CLASS(Dictionary) == p_type.type_class->get_raw()) { return mono_object_to_Dictionary(p_obj); } } break; } ERR_EXPLAIN(String() + "Attempted to convert an unmarshallable managed type to Variant. Name: \'" + p_type.type_class->get_name() + "\' Encoding: " + itos(p_type.type_encoding)); ERR_FAIL_V(Variant()); }
void GDMonoField::set_value(MonoObject *p_object, const Variant &p_value) { #define SET_FROM_STRUCT_AND_BREAK(m_type) \ { \ const m_type &val = p_value.operator m_type(); \ MARSHALLED_OUT(m_type, val, raw); \ mono_field_set_value(p_object, mono_field, raw); \ break; \ } #define SET_FROM_PRIMITIVE(m_type) \ { \ m_type val = p_value.operator m_type(); \ mono_field_set_value(p_object, mono_field, &val); \ break; \ } #define SET_FROM_ARRAY_AND_BREAK(m_type) \ { \ MonoArray *managed = GDMonoMarshal::m_type##_to_mono_array(p_value.operator m_type()); \ mono_field_set_value(p_object, mono_field, &managed); \ break; \ } switch (type.type_encoding) { case MONO_TYPE_BOOLEAN: { SET_FROM_PRIMITIVE(bool); } break; case MONO_TYPE_I1: { SET_FROM_PRIMITIVE(signed char); } break; case MONO_TYPE_I2: { SET_FROM_PRIMITIVE(signed short); } break; case MONO_TYPE_I4: { SET_FROM_PRIMITIVE(signed int); } break; case MONO_TYPE_I8: { SET_FROM_PRIMITIVE(int64_t); } break; case MONO_TYPE_U1: { SET_FROM_PRIMITIVE(unsigned char); } break; case MONO_TYPE_U2: { SET_FROM_PRIMITIVE(unsigned short); } break; case MONO_TYPE_U4: { SET_FROM_PRIMITIVE(unsigned int); } break; case MONO_TYPE_U8: { SET_FROM_PRIMITIVE(uint64_t); } break; case MONO_TYPE_R4: { SET_FROM_PRIMITIVE(float); } break; case MONO_TYPE_R8: { SET_FROM_PRIMITIVE(double); } 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; if (tclass == CACHED_CLASS(Vector2)) SET_FROM_STRUCT_AND_BREAK(Vector2); if (tclass == CACHED_CLASS(Rect2)) SET_FROM_STRUCT_AND_BREAK(Rect2); if (tclass == CACHED_CLASS(Transform2D)) SET_FROM_STRUCT_AND_BREAK(Transform2D); if (tclass == CACHED_CLASS(Vector3)) SET_FROM_STRUCT_AND_BREAK(Vector3); if (tclass == CACHED_CLASS(Basis)) SET_FROM_STRUCT_AND_BREAK(Basis); if (tclass == CACHED_CLASS(Quat)) SET_FROM_STRUCT_AND_BREAK(Quat); if (tclass == CACHED_CLASS(Transform)) SET_FROM_STRUCT_AND_BREAK(Transform); if (tclass == CACHED_CLASS(AABB)) SET_FROM_STRUCT_AND_BREAK(AABB); if (tclass == CACHED_CLASS(Color)) SET_FROM_STRUCT_AND_BREAK(Color); if (tclass == CACHED_CLASS(Plane)) SET_FROM_STRUCT_AND_BREAK(Plane); if (mono_class_is_enum(tclass->get_raw())) SET_FROM_PRIMITIVE(signed int); 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: { MonoArrayType *array_type = mono_type_get_array_type(GDMonoClass::get_raw_type(type.type_class)); if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) SET_FROM_ARRAY_AND_BREAK(Array); if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) SET_FROM_ARRAY_AND_BREAK(PoolByteArray); if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) SET_FROM_ARRAY_AND_BREAK(PoolIntArray); if (array_type->eklass == REAL_T_MONOCLASS) SET_FROM_ARRAY_AND_BREAK(PoolRealArray); if (array_type->eklass == CACHED_CLASS_RAW(String)) SET_FROM_ARRAY_AND_BREAK(PoolStringArray); if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) SET_FROM_ARRAY_AND_BREAK(PoolVector2Array); if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) SET_FROM_ARRAY_AND_BREAK(PoolVector3Array); if (array_type->eklass == CACHED_CLASS_RAW(Color)) SET_FROM_ARRAY_AND_BREAK(PoolColorArray); 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 *()); mono_field_set_value(p_object, mono_field, managed); break; } if (CACHED_CLASS(NodePath) == type_class) { MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath()); mono_field_set_value(p_object, mono_field, managed); break; } if (CACHED_CLASS(RID) == type_class) { MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID()); mono_field_set_value(p_object, mono_field, managed); break; } 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: { SET_FROM_PRIMITIVE(bool); } break; case Variant::INT: { SET_FROM_PRIMITIVE(int); } break; case Variant::REAL: { #ifdef REAL_T_IS_DOUBLE SET_FROM_PRIMITIVE(double); #else SET_FROM_PRIMITIVE(float); #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; case Variant::VECTOR2: SET_FROM_STRUCT_AND_BREAK(Vector2); case Variant::RECT2: SET_FROM_STRUCT_AND_BREAK(Rect2); case Variant::VECTOR3: SET_FROM_STRUCT_AND_BREAK(Vector3); case Variant::TRANSFORM2D: SET_FROM_STRUCT_AND_BREAK(Transform2D); case Variant::PLANE: SET_FROM_STRUCT_AND_BREAK(Plane); case Variant::QUAT: SET_FROM_STRUCT_AND_BREAK(Quat); case Variant::AABB: SET_FROM_STRUCT_AND_BREAK(AABB); case Variant::BASIS: SET_FROM_STRUCT_AND_BREAK(Basis); case Variant::TRANSFORM: SET_FROM_STRUCT_AND_BREAK(Transform); case Variant::COLOR: SET_FROM_STRUCT_AND_BREAK(Color); case Variant::NODE_PATH: { MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath()); mono_field_set_value(p_object, mono_field, managed); } break; case Variant::_RID: { MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID()); mono_field_set_value(p_object, mono_field, managed); } 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: { MonoObject *managed = GDMonoMarshal::Dictionary_to_mono_object(p_value.operator Dictionary()); mono_field_set_value(p_object, mono_field, managed); } break; case Variant::ARRAY: SET_FROM_ARRAY_AND_BREAK(Array); case Variant::POOL_BYTE_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolByteArray); case Variant::POOL_INT_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolIntArray); case Variant::POOL_REAL_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolRealArray); case Variant::POOL_STRING_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolStringArray); case Variant::POOL_VECTOR2_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolVector2Array); case Variant::POOL_VECTOR3_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolVector3Array); case Variant::POOL_COLOR_ARRAY: SET_FROM_ARRAY_AND_BREAK(PoolColorArray); #undef SET_FROM_ARRAY_AND_BREAK default: break; } } break; case MONO_TYPE_GENERICINST: { if (CACHED_RAW_MONO_CLASS(Dictionary) == type.type_class->get_raw()) { MonoObject *managed = GDMonoMarshal::Dictionary_to_mono_object(p_value.operator Dictionary()); mono_field_set_value(p_object, mono_field, managed); break; } } break; default: { ERR_PRINTS(String() + "Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding)); } break; } #undef SET_FROM_STRUCT_AND_BREAK #undef SET_FROM_PRIMITIVE }
MonoObject *variant_to_mono_object(const Variant *p_var, const ManagedType &p_type) { switch (p_type.type_encoding) { case MONO_TYPE_BOOLEAN: { MonoBoolean val = p_var->operator bool(); return BOX_BOOLEAN(val); } case MONO_TYPE_I1: { char val = p_var->operator signed char(); return BOX_INT8(val); } case MONO_TYPE_I2: { short val = p_var->operator signed short(); return BOX_INT16(val); } case MONO_TYPE_I4: { int val = p_var->operator signed int(); return BOX_INT32(val); } case MONO_TYPE_I8: { int64_t val = p_var->operator int64_t(); return BOX_INT64(val); } case MONO_TYPE_U1: { char val = p_var->operator unsigned char(); return BOX_UINT8(val); } case MONO_TYPE_U2: { short val = p_var->operator unsigned short(); return BOX_UINT16(val); } case MONO_TYPE_U4: { int val = p_var->operator unsigned int(); return BOX_UINT32(val); } case MONO_TYPE_U8: { uint64_t val = p_var->operator uint64_t(); return BOX_UINT64(val); } case MONO_TYPE_R4: { float val = p_var->operator float(); return BOX_FLOAT(val); } case MONO_TYPE_R8: { double val = p_var->operator double(); return BOX_DOUBLE(val); } case MONO_TYPE_STRING: { return (MonoObject *)mono_string_from_godot(p_var->operator String()); } break; case MONO_TYPE_VALUETYPE: { GDMonoClass *tclass = p_type.type_class; if (tclass == CACHED_CLASS(Vector2)) RETURN_BOXED_STRUCT(Vector2, p_var); if (tclass == CACHED_CLASS(Rect2)) RETURN_BOXED_STRUCT(Rect2, p_var); if (tclass == CACHED_CLASS(Transform2D)) RETURN_BOXED_STRUCT(Transform2D, p_var); if (tclass == CACHED_CLASS(Vector3)) RETURN_BOXED_STRUCT(Vector3, p_var); if (tclass == CACHED_CLASS(Basis)) RETURN_BOXED_STRUCT(Basis, p_var); if (tclass == CACHED_CLASS(Quat)) RETURN_BOXED_STRUCT(Quat, p_var); if (tclass == CACHED_CLASS(Transform)) RETURN_BOXED_STRUCT(Transform, p_var); if (tclass == CACHED_CLASS(Rect3)) RETURN_BOXED_STRUCT(Rect3, p_var); if (tclass == CACHED_CLASS(Color)) RETURN_BOXED_STRUCT(Color, p_var); if (tclass == CACHED_CLASS(Plane)) RETURN_BOXED_STRUCT(Plane, p_var); if (mono_class_is_enum(tclass->get_raw())) { int val = p_var->operator signed int(); return BOX_ENUM(tclass->get_raw(), val); } } break; case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: { MonoArrayType *array_type = mono_type_get_array_type(GDMonoClass::get_raw_type(p_type.type_class)); if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) return (MonoObject *)Array_to_mono_array(p_var->operator Array()); if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) return (MonoObject *)PoolByteArray_to_mono_array(p_var->operator PoolByteArray()); if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) return (MonoObject *)PoolIntArray_to_mono_array(p_var->operator PoolIntArray()); if (array_type->eklass == REAL_T_MONOCLASS) return (MonoObject *)PoolRealArray_to_mono_array(p_var->operator PoolRealArray()); if (array_type->eklass == CACHED_CLASS_RAW(String)) return (MonoObject *)PoolStringArray_to_mono_array(p_var->operator PoolStringArray()); if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) return (MonoObject *)PoolVector2Array_to_mono_array(p_var->operator PoolVector2Array()); if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) return (MonoObject *)PoolVector3Array_to_mono_array(p_var->operator PoolVector3Array()); if (array_type->eklass == CACHED_CLASS_RAW(Color)) return (MonoObject *)PoolColorArray_to_mono_array(p_var->operator PoolColorArray()); ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed array of unmarshallable element type."); ERR_FAIL_V(NULL); } break; case MONO_TYPE_CLASS: { GDMonoClass *type_class = p_type.type_class; // GodotObject if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) { return GDMonoUtils::unmanaged_get_managed(p_var->operator Object *()); } if (CACHED_CLASS(NodePath) == type_class) { return GDMonoUtils::create_managed_from(p_var->operator NodePath()); } if (CACHED_CLASS(RID) == type_class) { return GDMonoUtils::create_managed_from(p_var->operator RID()); } } break; case MONO_TYPE_OBJECT: { // Variant switch (p_var->get_type()) { case Variant::BOOL: { MonoBoolean val = p_var->operator bool(); return BOX_BOOLEAN(val); } case Variant::INT: { int val = p_var->operator signed int(); return BOX_INT32(val); } case Variant::REAL: { #ifdef REAL_T_IS_DOUBLE double val = p_var->operator double(); return BOX_DOUBLE(val); #else float val = p_var->operator float(); return BOX_FLOAT(val); #endif } case Variant::STRING: return (MonoObject *)mono_string_from_godot(p_var->operator String()); case Variant::VECTOR2: RETURN_BOXED_STRUCT(Vector2, p_var); case Variant::RECT2: RETURN_BOXED_STRUCT(Rect2, p_var); case Variant::VECTOR3: RETURN_BOXED_STRUCT(Vector3, p_var); case Variant::TRANSFORM2D: RETURN_BOXED_STRUCT(Transform2D, p_var); case Variant::PLANE: RETURN_BOXED_STRUCT(Plane, p_var); case Variant::QUAT: RETURN_BOXED_STRUCT(Quat, p_var); case Variant::RECT3: RETURN_BOXED_STRUCT(Rect3, p_var); case Variant::BASIS: RETURN_BOXED_STRUCT(Basis, p_var); case Variant::TRANSFORM: RETURN_BOXED_STRUCT(Transform, p_var); case Variant::COLOR: RETURN_BOXED_STRUCT(Color, p_var); case Variant::NODE_PATH: return GDMonoUtils::create_managed_from(p_var->operator NodePath()); case Variant::_RID: return GDMonoUtils::create_managed_from(p_var->operator RID()); case Variant::OBJECT: { return GDMonoUtils::unmanaged_get_managed(p_var->operator Object *()); } case Variant::DICTIONARY: return Dictionary_to_mono_object(p_var->operator Dictionary()); case Variant::ARRAY: return (MonoObject *)Array_to_mono_array(p_var->operator Array()); case Variant::POOL_BYTE_ARRAY: return (MonoObject *)PoolByteArray_to_mono_array(p_var->operator PoolByteArray()); case Variant::POOL_INT_ARRAY: return (MonoObject *)PoolIntArray_to_mono_array(p_var->operator PoolIntArray()); case Variant::POOL_REAL_ARRAY: return (MonoObject *)PoolRealArray_to_mono_array(p_var->operator PoolRealArray()); case Variant::POOL_STRING_ARRAY: return (MonoObject *)PoolStringArray_to_mono_array(p_var->operator PoolStringArray()); case Variant::POOL_VECTOR2_ARRAY: return (MonoObject *)PoolVector2Array_to_mono_array(p_var->operator PoolVector2Array()); case Variant::POOL_VECTOR3_ARRAY: return (MonoObject *)PoolVector3Array_to_mono_array(p_var->operator PoolVector3Array()); case Variant::POOL_COLOR_ARRAY: return (MonoObject *)PoolColorArray_to_mono_array(p_var->operator PoolColorArray()); default: return NULL; } break; case MONO_TYPE_GENERICINST: { if (CACHED_RAW_MONO_CLASS(Dictionary) == p_type.type_class->get_raw()) { return Dictionary_to_mono_object(p_var->operator Dictionary()); } } break; } break; } ERR_EXPLAIN(String() + "Attempted to convert Variant to an unmarshallable managed type. Name: \'" + p_type.type_class->get_name() + "\' Encoding: " + itos(p_type.type_encoding)); ERR_FAIL_V(NULL); }