gd_mono_field.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543
  1. /*************************************************************************/
  2. /* gd_mono_field.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "gd_mono_field.h"
  31. #include <mono/metadata/attrdefs.h>
  32. #include "gd_mono_class.h"
  33. #include "gd_mono_marshal.h"
  34. void GDMonoField::set_value_raw(MonoObject *p_object, void *p_ptr) {
  35. mono_field_set_value(p_object, mono_field, &p_ptr);
  36. }
  37. void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_value) {
  38. #define SET_FROM_STRUCT(m_type) \
  39. { \
  40. GDMonoMarshal::M_##m_type from = MARSHALLED_OUT(m_type, p_value.operator ::m_type()); \
  41. mono_field_set_value(p_object, mono_field, &from); \
  42. }
  43. #define SET_FROM_ARRAY(m_type) \
  44. { \
  45. MonoArray *managed = GDMonoMarshal::m_type##_to_mono_array(p_value.operator ::m_type()); \
  46. mono_field_set_value(p_object, mono_field, &managed); \
  47. }
  48. switch (type.type_encoding) {
  49. case MONO_TYPE_BOOLEAN: {
  50. MonoBoolean val = p_value.operator bool();
  51. mono_field_set_value(p_object, mono_field, &val);
  52. } break;
  53. case MONO_TYPE_CHAR: {
  54. int16_t val = p_value.operator unsigned short();
  55. mono_field_set_value(p_object, mono_field, &val);
  56. } break;
  57. case MONO_TYPE_I1: {
  58. int8_t val = p_value.operator signed char();
  59. mono_field_set_value(p_object, mono_field, &val);
  60. } break;
  61. case MONO_TYPE_I2: {
  62. int16_t val = p_value.operator signed short();
  63. mono_field_set_value(p_object, mono_field, &val);
  64. } break;
  65. case MONO_TYPE_I4: {
  66. int32_t val = p_value.operator signed int();
  67. mono_field_set_value(p_object, mono_field, &val);
  68. } break;
  69. case MONO_TYPE_I8: {
  70. int64_t val = p_value.operator int64_t();
  71. mono_field_set_value(p_object, mono_field, &val);
  72. } break;
  73. case MONO_TYPE_U1: {
  74. uint8_t val = p_value.operator unsigned char();
  75. mono_field_set_value(p_object, mono_field, &val);
  76. } break;
  77. case MONO_TYPE_U2: {
  78. uint16_t val = p_value.operator unsigned short();
  79. mono_field_set_value(p_object, mono_field, &val);
  80. } break;
  81. case MONO_TYPE_U4: {
  82. uint32_t val = p_value.operator unsigned int();
  83. mono_field_set_value(p_object, mono_field, &val);
  84. } break;
  85. case MONO_TYPE_U8: {
  86. uint64_t val = p_value.operator uint64_t();
  87. mono_field_set_value(p_object, mono_field, &val);
  88. } break;
  89. case MONO_TYPE_R4: {
  90. float val = p_value.operator float();
  91. mono_field_set_value(p_object, mono_field, &val);
  92. } break;
  93. case MONO_TYPE_R8: {
  94. double val = p_value.operator double();
  95. mono_field_set_value(p_object, mono_field, &val);
  96. } break;
  97. case MONO_TYPE_STRING: {
  98. MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
  99. mono_field_set_value(p_object, mono_field, mono_string);
  100. } break;
  101. case MONO_TYPE_VALUETYPE: {
  102. GDMonoClass *tclass = type.type_class;
  103. if (tclass == CACHED_CLASS(Vector2)) {
  104. SET_FROM_STRUCT(Vector2);
  105. break;
  106. }
  107. if (tclass == CACHED_CLASS(Rect2)) {
  108. SET_FROM_STRUCT(Rect2);
  109. break;
  110. }
  111. if (tclass == CACHED_CLASS(Transform2D)) {
  112. SET_FROM_STRUCT(Transform2D);
  113. break;
  114. }
  115. if (tclass == CACHED_CLASS(Vector3)) {
  116. SET_FROM_STRUCT(Vector3);
  117. break;
  118. }
  119. if (tclass == CACHED_CLASS(Basis)) {
  120. SET_FROM_STRUCT(Basis);
  121. break;
  122. }
  123. if (tclass == CACHED_CLASS(Quat)) {
  124. SET_FROM_STRUCT(Quat);
  125. break;
  126. }
  127. if (tclass == CACHED_CLASS(Transform)) {
  128. SET_FROM_STRUCT(Transform);
  129. break;
  130. }
  131. if (tclass == CACHED_CLASS(AABB)) {
  132. SET_FROM_STRUCT(AABB);
  133. break;
  134. }
  135. if (tclass == CACHED_CLASS(Color)) {
  136. SET_FROM_STRUCT(Color);
  137. break;
  138. }
  139. if (tclass == CACHED_CLASS(Plane)) {
  140. SET_FROM_STRUCT(Plane);
  141. break;
  142. }
  143. if (mono_class_is_enum(tclass->get_mono_ptr())) {
  144. MonoType *enum_basetype = mono_class_enum_basetype(tclass->get_mono_ptr());
  145. switch (mono_type_get_type(enum_basetype)) {
  146. case MONO_TYPE_BOOLEAN: {
  147. MonoBoolean val = p_value.operator bool();
  148. mono_field_set_value(p_object, mono_field, &val);
  149. break;
  150. }
  151. case MONO_TYPE_CHAR: {
  152. uint16_t val = p_value.operator unsigned short();
  153. mono_field_set_value(p_object, mono_field, &val);
  154. break;
  155. }
  156. case MONO_TYPE_I1: {
  157. int8_t val = p_value.operator signed char();
  158. mono_field_set_value(p_object, mono_field, &val);
  159. break;
  160. }
  161. case MONO_TYPE_I2: {
  162. int16_t val = p_value.operator signed short();
  163. mono_field_set_value(p_object, mono_field, &val);
  164. break;
  165. }
  166. case MONO_TYPE_I4: {
  167. int32_t val = p_value.operator signed int();
  168. mono_field_set_value(p_object, mono_field, &val);
  169. break;
  170. }
  171. case MONO_TYPE_I8: {
  172. int64_t val = p_value.operator int64_t();
  173. mono_field_set_value(p_object, mono_field, &val);
  174. break;
  175. }
  176. case MONO_TYPE_U1: {
  177. uint8_t val = p_value.operator unsigned char();
  178. mono_field_set_value(p_object, mono_field, &val);
  179. break;
  180. }
  181. case MONO_TYPE_U2: {
  182. uint16_t val = p_value.operator unsigned short();
  183. mono_field_set_value(p_object, mono_field, &val);
  184. break;
  185. }
  186. case MONO_TYPE_U4: {
  187. uint32_t val = p_value.operator unsigned int();
  188. mono_field_set_value(p_object, mono_field, &val);
  189. break;
  190. }
  191. case MONO_TYPE_U8: {
  192. uint64_t val = p_value.operator uint64_t();
  193. mono_field_set_value(p_object, mono_field, &val);
  194. break;
  195. }
  196. default: {
  197. ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed enum value of unmarshallable base type.");
  198. ERR_FAIL();
  199. }
  200. }
  201. break;
  202. }
  203. ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + tclass->get_name());
  204. ERR_FAIL();
  205. } break;
  206. case MONO_TYPE_ARRAY:
  207. case MONO_TYPE_SZARRAY: {
  208. MonoArrayType *array_type = mono_type_get_array_type(type.type_class->get_mono_type());
  209. if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
  210. SET_FROM_ARRAY(Array);
  211. break;
  212. }
  213. if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
  214. SET_FROM_ARRAY(PoolByteArray);
  215. break;
  216. }
  217. if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
  218. SET_FROM_ARRAY(PoolIntArray);
  219. break;
  220. }
  221. if (array_type->eklass == REAL_T_MONOCLASS) {
  222. SET_FROM_ARRAY(PoolRealArray);
  223. break;
  224. }
  225. if (array_type->eklass == CACHED_CLASS_RAW(String)) {
  226. SET_FROM_ARRAY(PoolStringArray);
  227. break;
  228. }
  229. if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
  230. SET_FROM_ARRAY(PoolVector2Array);
  231. break;
  232. }
  233. if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
  234. SET_FROM_ARRAY(PoolVector3Array);
  235. break;
  236. }
  237. if (array_type->eklass == CACHED_CLASS_RAW(Color)) {
  238. SET_FROM_ARRAY(PoolColorArray);
  239. break;
  240. }
  241. ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed array of unmarshallable element type.");
  242. ERR_FAIL();
  243. } break;
  244. case MONO_TYPE_CLASS: {
  245. GDMonoClass *type_class = type.type_class;
  246. // GodotObject
  247. if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
  248. MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
  249. mono_field_set_value(p_object, mono_field, managed);
  250. break;
  251. }
  252. if (CACHED_CLASS(NodePath) == type_class) {
  253. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
  254. mono_field_set_value(p_object, mono_field, managed);
  255. break;
  256. }
  257. if (CACHED_CLASS(RID) == type_class) {
  258. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
  259. mono_field_set_value(p_object, mono_field, managed);
  260. break;
  261. }
  262. if (CACHED_CLASS(Dictionary) == type_class) {
  263. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
  264. mono_field_set_value(p_object, mono_field, managed);
  265. break;
  266. }
  267. if (CACHED_CLASS(Array) == type_class) {
  268. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
  269. mono_field_set_value(p_object, mono_field, managed);
  270. break;
  271. }
  272. ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + type_class->get_name());
  273. ERR_FAIL();
  274. } break;
  275. case MONO_TYPE_OBJECT: {
  276. // Variant
  277. switch (p_value.get_type()) {
  278. case Variant::BOOL: {
  279. MonoBoolean val = p_value.operator bool();
  280. mono_field_set_value(p_object, mono_field, &val);
  281. } break;
  282. case Variant::INT: {
  283. int32_t val = p_value.operator signed int();
  284. mono_field_set_value(p_object, mono_field, &val);
  285. } break;
  286. case Variant::REAL: {
  287. #ifdef REAL_T_IS_DOUBLE
  288. double val = p_value.operator double();
  289. mono_field_set_value(p_object, mono_field, &val);
  290. #else
  291. float val = p_value.operator float();
  292. mono_field_set_value(p_object, mono_field, &val);
  293. #endif
  294. } break;
  295. case Variant::STRING: {
  296. MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
  297. mono_field_set_value(p_object, mono_field, mono_string);
  298. } break;
  299. case Variant::VECTOR2: {
  300. SET_FROM_STRUCT(Vector2);
  301. } break;
  302. case Variant::RECT2: {
  303. SET_FROM_STRUCT(Rect2);
  304. } break;
  305. case Variant::VECTOR3: {
  306. SET_FROM_STRUCT(Vector3);
  307. } break;
  308. case Variant::TRANSFORM2D: {
  309. SET_FROM_STRUCT(Transform2D);
  310. } break;
  311. case Variant::PLANE: {
  312. SET_FROM_STRUCT(Plane);
  313. } break;
  314. case Variant::QUAT: {
  315. SET_FROM_STRUCT(Quat);
  316. } break;
  317. case Variant::AABB: {
  318. SET_FROM_STRUCT(AABB);
  319. } break;
  320. case Variant::BASIS: {
  321. SET_FROM_STRUCT(Basis);
  322. } break;
  323. case Variant::TRANSFORM: {
  324. SET_FROM_STRUCT(Transform);
  325. } break;
  326. case Variant::COLOR: {
  327. SET_FROM_STRUCT(Color);
  328. } break;
  329. case Variant::NODE_PATH: {
  330. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
  331. mono_field_set_value(p_object, mono_field, managed);
  332. } break;
  333. case Variant::_RID: {
  334. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
  335. mono_field_set_value(p_object, mono_field, managed);
  336. } break;
  337. case Variant::OBJECT: {
  338. MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
  339. mono_field_set_value(p_object, mono_field, managed);
  340. break;
  341. }
  342. case Variant::DICTIONARY: {
  343. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
  344. mono_field_set_value(p_object, mono_field, managed);
  345. } break;
  346. case Variant::ARRAY: {
  347. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
  348. mono_field_set_value(p_object, mono_field, managed);
  349. } break;
  350. case Variant::POOL_BYTE_ARRAY: {
  351. SET_FROM_ARRAY(PoolByteArray);
  352. } break;
  353. case Variant::POOL_INT_ARRAY: {
  354. SET_FROM_ARRAY(PoolIntArray);
  355. } break;
  356. case Variant::POOL_REAL_ARRAY: {
  357. SET_FROM_ARRAY(PoolRealArray);
  358. } break;
  359. case Variant::POOL_STRING_ARRAY: {
  360. SET_FROM_ARRAY(PoolStringArray);
  361. } break;
  362. case Variant::POOL_VECTOR2_ARRAY: {
  363. SET_FROM_ARRAY(PoolVector2Array);
  364. } break;
  365. case Variant::POOL_VECTOR3_ARRAY: {
  366. SET_FROM_ARRAY(PoolVector3Array);
  367. } break;
  368. case Variant::POOL_COLOR_ARRAY: {
  369. SET_FROM_ARRAY(PoolColorArray);
  370. } break;
  371. default: break;
  372. }
  373. } break;
  374. case MONO_TYPE_GENERICINST: {
  375. MonoReflectionType *reftype = mono_type_get_object(SCRIPTS_DOMAIN, type.type_class->get_mono_type());
  376. MonoException *exc = NULL;
  377. GDMonoUtils::IsDictionaryGenericType type_is_dict = CACHED_METHOD_THUNK(MarshalUtils, IsDictionaryGenericType);
  378. MonoBoolean is_dict = invoke_method_thunk(type_is_dict, (MonoObject *)reftype, (MonoObject **)&exc);
  379. UNLIKELY_UNHANDLED_EXCEPTION(exc);
  380. if (is_dict) {
  381. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), type.type_class);
  382. mono_field_set_value(p_object, mono_field, managed);
  383. break;
  384. }
  385. exc = NULL;
  386. GDMonoUtils::IsArrayGenericType type_is_array = CACHED_METHOD_THUNK(MarshalUtils, IsArrayGenericType);
  387. MonoBoolean is_array = invoke_method_thunk(type_is_array, (MonoObject *)reftype, (MonoObject **)&exc);
  388. UNLIKELY_UNHANDLED_EXCEPTION(exc);
  389. if (is_array) {
  390. MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), type.type_class);
  391. mono_field_set_value(p_object, mono_field, managed);
  392. break;
  393. }
  394. } break;
  395. default: {
  396. ERR_PRINTS(String() + "Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding));
  397. } break;
  398. }
  399. #undef SET_FROM_ARRAY_AND_BREAK
  400. #undef SET_FROM_STRUCT_AND_BREAK
  401. }
  402. MonoObject *GDMonoField::get_value(MonoObject *p_object) {
  403. return mono_field_get_value_object(mono_domain_get(), mono_field, p_object);
  404. }
  405. bool GDMonoField::get_bool_value(MonoObject *p_object) {
  406. return (bool)GDMonoMarshal::unbox<MonoBoolean>(get_value(p_object));
  407. }
  408. int GDMonoField::get_int_value(MonoObject *p_object) {
  409. return GDMonoMarshal::unbox<int32_t>(get_value(p_object));
  410. }
  411. String GDMonoField::get_string_value(MonoObject *p_object) {
  412. MonoObject *val = get_value(p_object);
  413. return GDMonoMarshal::mono_string_to_godot((MonoString *)val);
  414. }
  415. bool GDMonoField::has_attribute(GDMonoClass *p_attr_class) {
  416. ERR_FAIL_NULL_V(p_attr_class, false);
  417. if (!attrs_fetched)
  418. fetch_attributes();
  419. if (!attributes)
  420. return false;
  421. return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr());
  422. }
  423. MonoObject *GDMonoField::get_attribute(GDMonoClass *p_attr_class) {
  424. ERR_FAIL_NULL_V(p_attr_class, NULL);
  425. if (!attrs_fetched)
  426. fetch_attributes();
  427. if (!attributes)
  428. return NULL;
  429. return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr());
  430. }
  431. void GDMonoField::fetch_attributes() {
  432. ERR_FAIL_COND(attributes != NULL);
  433. attributes = mono_custom_attrs_from_field(owner->get_mono_ptr(), mono_field);
  434. attrs_fetched = true;
  435. }
  436. bool GDMonoField::is_static() {
  437. return mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_STATIC;
  438. }
  439. GDMonoClassMember::Visibility GDMonoField::get_visibility() {
  440. switch (mono_field_get_flags(mono_field) & MONO_FIELD_ATTR_FIELD_ACCESS_MASK) {
  441. case MONO_FIELD_ATTR_PRIVATE:
  442. return GDMonoClassMember::PRIVATE;
  443. case MONO_FIELD_ATTR_FAM_AND_ASSEM:
  444. return GDMonoClassMember::PROTECTED_AND_INTERNAL;
  445. case MONO_FIELD_ATTR_ASSEMBLY:
  446. return GDMonoClassMember::INTERNAL;
  447. case MONO_FIELD_ATTR_FAMILY:
  448. return GDMonoClassMember::PROTECTED;
  449. case MONO_FIELD_ATTR_PUBLIC:
  450. return GDMonoClassMember::PUBLIC;
  451. default:
  452. ERR_FAIL_V(GDMonoClassMember::PRIVATE);
  453. }
  454. }
  455. GDMonoField::GDMonoField(MonoClassField *p_mono_field, GDMonoClass *p_owner) {
  456. owner = p_owner;
  457. mono_field = p_mono_field;
  458. name = mono_field_get_name(mono_field);
  459. MonoType *field_type = mono_field_get_type(mono_field);
  460. type.type_encoding = mono_type_get_type(field_type);
  461. MonoClass *field_type_class = mono_class_from_mono_type(field_type);
  462. type.type_class = GDMono::get_singleton()->get_class(field_type_class);
  463. attrs_fetched = false;
  464. attributes = NULL;
  465. }
  466. GDMonoField::~GDMonoField() {
  467. if (attributes) {
  468. mono_custom_attrs_free(attributes);
  469. }
  470. }