class_db.cpp 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696
  1. /*************************************************************************/
  2. /* class_db.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2021 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 "class_db.h"
  31. #include "core/config/engine.h"
  32. #include "core/os/mutex.h"
  33. #include "core/version.h"
  34. #define OBJTYPE_RLOCK RWLockRead _rw_lockr_(lock);
  35. #define OBJTYPE_WLOCK RWLockWrite _rw_lockw_(lock);
  36. #ifdef DEBUG_METHODS_ENABLED
  37. MethodDefinition D_METHOD(const char *p_name) {
  38. MethodDefinition md;
  39. md.name = StaticCString::create(p_name);
  40. return md;
  41. }
  42. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1) {
  43. MethodDefinition md;
  44. md.name = StaticCString::create(p_name);
  45. md.args.push_back(StaticCString::create(p_arg1));
  46. return md;
  47. }
  48. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2) {
  49. MethodDefinition md;
  50. md.name = StaticCString::create(p_name);
  51. md.args.resize(2);
  52. md.args.write[0] = StaticCString::create(p_arg1);
  53. md.args.write[1] = StaticCString::create(p_arg2);
  54. return md;
  55. }
  56. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3) {
  57. MethodDefinition md;
  58. md.name = StaticCString::create(p_name);
  59. md.args.resize(3);
  60. md.args.write[0] = StaticCString::create(p_arg1);
  61. md.args.write[1] = StaticCString::create(p_arg2);
  62. md.args.write[2] = StaticCString::create(p_arg3);
  63. return md;
  64. }
  65. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4) {
  66. MethodDefinition md;
  67. md.name = StaticCString::create(p_name);
  68. md.args.resize(4);
  69. md.args.write[0] = StaticCString::create(p_arg1);
  70. md.args.write[1] = StaticCString::create(p_arg2);
  71. md.args.write[2] = StaticCString::create(p_arg3);
  72. md.args.write[3] = StaticCString::create(p_arg4);
  73. return md;
  74. }
  75. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5) {
  76. MethodDefinition md;
  77. md.name = StaticCString::create(p_name);
  78. md.args.resize(5);
  79. md.args.write[0] = StaticCString::create(p_arg1);
  80. md.args.write[1] = StaticCString::create(p_arg2);
  81. md.args.write[2] = StaticCString::create(p_arg3);
  82. md.args.write[3] = StaticCString::create(p_arg4);
  83. md.args.write[4] = StaticCString::create(p_arg5);
  84. return md;
  85. }
  86. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6) {
  87. MethodDefinition md;
  88. md.name = StaticCString::create(p_name);
  89. md.args.resize(6);
  90. md.args.write[0] = StaticCString::create(p_arg1);
  91. md.args.write[1] = StaticCString::create(p_arg2);
  92. md.args.write[2] = StaticCString::create(p_arg3);
  93. md.args.write[3] = StaticCString::create(p_arg4);
  94. md.args.write[4] = StaticCString::create(p_arg5);
  95. md.args.write[5] = StaticCString::create(p_arg6);
  96. return md;
  97. }
  98. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7) {
  99. MethodDefinition md;
  100. md.name = StaticCString::create(p_name);
  101. md.args.resize(7);
  102. md.args.write[0] = StaticCString::create(p_arg1);
  103. md.args.write[1] = StaticCString::create(p_arg2);
  104. md.args.write[2] = StaticCString::create(p_arg3);
  105. md.args.write[3] = StaticCString::create(p_arg4);
  106. md.args.write[4] = StaticCString::create(p_arg5);
  107. md.args.write[5] = StaticCString::create(p_arg6);
  108. md.args.write[6] = StaticCString::create(p_arg7);
  109. return md;
  110. }
  111. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8) {
  112. MethodDefinition md;
  113. md.name = StaticCString::create(p_name);
  114. md.args.resize(8);
  115. md.args.write[0] = StaticCString::create(p_arg1);
  116. md.args.write[1] = StaticCString::create(p_arg2);
  117. md.args.write[2] = StaticCString::create(p_arg3);
  118. md.args.write[3] = StaticCString::create(p_arg4);
  119. md.args.write[4] = StaticCString::create(p_arg5);
  120. md.args.write[5] = StaticCString::create(p_arg6);
  121. md.args.write[6] = StaticCString::create(p_arg7);
  122. md.args.write[7] = StaticCString::create(p_arg8);
  123. return md;
  124. }
  125. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8, const char *p_arg9) {
  126. MethodDefinition md;
  127. md.name = StaticCString::create(p_name);
  128. md.args.resize(9);
  129. md.args.write[0] = StaticCString::create(p_arg1);
  130. md.args.write[1] = StaticCString::create(p_arg2);
  131. md.args.write[2] = StaticCString::create(p_arg3);
  132. md.args.write[3] = StaticCString::create(p_arg4);
  133. md.args.write[4] = StaticCString::create(p_arg5);
  134. md.args.write[5] = StaticCString::create(p_arg6);
  135. md.args.write[6] = StaticCString::create(p_arg7);
  136. md.args.write[7] = StaticCString::create(p_arg8);
  137. md.args.write[8] = StaticCString::create(p_arg9);
  138. return md;
  139. }
  140. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8, const char *p_arg9, const char *p_arg10) {
  141. MethodDefinition md;
  142. md.name = StaticCString::create(p_name);
  143. md.args.resize(10);
  144. md.args.write[0] = StaticCString::create(p_arg1);
  145. md.args.write[1] = StaticCString::create(p_arg2);
  146. md.args.write[2] = StaticCString::create(p_arg3);
  147. md.args.write[3] = StaticCString::create(p_arg4);
  148. md.args.write[4] = StaticCString::create(p_arg5);
  149. md.args.write[5] = StaticCString::create(p_arg6);
  150. md.args.write[6] = StaticCString::create(p_arg7);
  151. md.args.write[7] = StaticCString::create(p_arg8);
  152. md.args.write[8] = StaticCString::create(p_arg9);
  153. md.args.write[9] = StaticCString::create(p_arg10);
  154. return md;
  155. }
  156. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8, const char *p_arg9, const char *p_arg10, const char *p_arg11) {
  157. MethodDefinition md;
  158. md.name = StaticCString::create(p_name);
  159. md.args.resize(11);
  160. md.args.write[0] = StaticCString::create(p_arg1);
  161. md.args.write[1] = StaticCString::create(p_arg2);
  162. md.args.write[2] = StaticCString::create(p_arg3);
  163. md.args.write[3] = StaticCString::create(p_arg4);
  164. md.args.write[4] = StaticCString::create(p_arg5);
  165. md.args.write[5] = StaticCString::create(p_arg6);
  166. md.args.write[6] = StaticCString::create(p_arg7);
  167. md.args.write[7] = StaticCString::create(p_arg8);
  168. md.args.write[8] = StaticCString::create(p_arg9);
  169. md.args.write[9] = StaticCString::create(p_arg10);
  170. md.args.write[10] = StaticCString::create(p_arg11);
  171. return md;
  172. }
  173. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8, const char *p_arg9, const char *p_arg10, const char *p_arg11, const char *p_arg12) {
  174. MethodDefinition md;
  175. md.name = StaticCString::create(p_name);
  176. md.args.resize(12);
  177. md.args.write[0] = StaticCString::create(p_arg1);
  178. md.args.write[1] = StaticCString::create(p_arg2);
  179. md.args.write[2] = StaticCString::create(p_arg3);
  180. md.args.write[3] = StaticCString::create(p_arg4);
  181. md.args.write[4] = StaticCString::create(p_arg5);
  182. md.args.write[5] = StaticCString::create(p_arg6);
  183. md.args.write[6] = StaticCString::create(p_arg7);
  184. md.args.write[7] = StaticCString::create(p_arg8);
  185. md.args.write[8] = StaticCString::create(p_arg9);
  186. md.args.write[9] = StaticCString::create(p_arg10);
  187. md.args.write[10] = StaticCString::create(p_arg11);
  188. md.args.write[11] = StaticCString::create(p_arg12);
  189. return md;
  190. }
  191. MethodDefinition D_METHOD(const char *p_name, const char *p_arg1, const char *p_arg2, const char *p_arg3, const char *p_arg4, const char *p_arg5, const char *p_arg6, const char *p_arg7, const char *p_arg8, const char *p_arg9, const char *p_arg10, const char *p_arg11, const char *p_arg12, const char *p_arg13) {
  192. MethodDefinition md;
  193. md.name = StaticCString::create(p_name);
  194. md.args.resize(13);
  195. md.args.write[0] = StaticCString::create(p_arg1);
  196. md.args.write[1] = StaticCString::create(p_arg2);
  197. md.args.write[2] = StaticCString::create(p_arg3);
  198. md.args.write[3] = StaticCString::create(p_arg4);
  199. md.args.write[4] = StaticCString::create(p_arg5);
  200. md.args.write[5] = StaticCString::create(p_arg6);
  201. md.args.write[6] = StaticCString::create(p_arg7);
  202. md.args.write[7] = StaticCString::create(p_arg8);
  203. md.args.write[8] = StaticCString::create(p_arg9);
  204. md.args.write[9] = StaticCString::create(p_arg10);
  205. md.args.write[10] = StaticCString::create(p_arg11);
  206. md.args.write[11] = StaticCString::create(p_arg12);
  207. md.args.write[12] = StaticCString::create(p_arg13);
  208. return md;
  209. }
  210. #endif
  211. ClassDB::APIType ClassDB::current_api = API_CORE;
  212. void ClassDB::set_current_api(APIType p_api) {
  213. current_api = p_api;
  214. }
  215. ClassDB::APIType ClassDB::get_current_api() {
  216. return current_api;
  217. }
  218. HashMap<StringName, ClassDB::ClassInfo> ClassDB::classes;
  219. HashMap<StringName, StringName> ClassDB::resource_base_extensions;
  220. HashMap<StringName, StringName> ClassDB::compat_classes;
  221. bool ClassDB::_is_parent_class(const StringName &p_class, const StringName &p_inherits) {
  222. if (!classes.has(p_class)) {
  223. return false;
  224. }
  225. StringName inherits = p_class;
  226. while (inherits.operator String().length()) {
  227. if (inherits == p_inherits) {
  228. return true;
  229. }
  230. inherits = _get_parent_class(inherits);
  231. }
  232. return false;
  233. }
  234. bool ClassDB::is_parent_class(const StringName &p_class, const StringName &p_inherits) {
  235. OBJTYPE_RLOCK;
  236. return _is_parent_class(p_class, p_inherits);
  237. }
  238. void ClassDB::get_class_list(List<StringName> *p_classes) {
  239. OBJTYPE_RLOCK;
  240. const StringName *k = nullptr;
  241. while ((k = classes.next(k))) {
  242. p_classes->push_back(*k);
  243. }
  244. p_classes->sort();
  245. }
  246. void ClassDB::get_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes) {
  247. OBJTYPE_RLOCK;
  248. const StringName *k = nullptr;
  249. while ((k = classes.next(k))) {
  250. if (*k != p_class && _is_parent_class(*k, p_class)) {
  251. p_classes->push_back(*k);
  252. }
  253. }
  254. }
  255. void ClassDB::get_direct_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes) {
  256. OBJTYPE_RLOCK;
  257. const StringName *k = nullptr;
  258. while ((k = classes.next(k))) {
  259. if (*k != p_class && _get_parent_class(*k) == p_class) {
  260. p_classes->push_back(*k);
  261. }
  262. }
  263. }
  264. StringName ClassDB::get_parent_class_nocheck(const StringName &p_class) {
  265. OBJTYPE_RLOCK;
  266. ClassInfo *ti = classes.getptr(p_class);
  267. if (!ti) {
  268. return StringName();
  269. }
  270. return ti->inherits;
  271. }
  272. StringName ClassDB::get_compatibility_remapped_class(const StringName &p_class) {
  273. if (classes.has(p_class)) {
  274. return p_class;
  275. }
  276. if (compat_classes.has(p_class)) {
  277. return compat_classes[p_class];
  278. }
  279. return p_class;
  280. }
  281. StringName ClassDB::_get_parent_class(const StringName &p_class) {
  282. ClassInfo *ti = classes.getptr(p_class);
  283. ERR_FAIL_COND_V_MSG(!ti, StringName(), "Cannot get class '" + String(p_class) + "'.");
  284. return ti->inherits;
  285. }
  286. StringName ClassDB::get_parent_class(const StringName &p_class) {
  287. OBJTYPE_RLOCK;
  288. return _get_parent_class(p_class);
  289. }
  290. ClassDB::APIType ClassDB::get_api_type(const StringName &p_class) {
  291. OBJTYPE_RLOCK;
  292. ClassInfo *ti = classes.getptr(p_class);
  293. ERR_FAIL_COND_V_MSG(!ti, API_NONE, "Cannot get class '" + String(p_class) + "'.");
  294. return ti->api;
  295. }
  296. uint64_t ClassDB::get_api_hash(APIType p_api) {
  297. OBJTYPE_RLOCK;
  298. #ifdef DEBUG_METHODS_ENABLED
  299. uint64_t hash = hash_djb2_one_64(HashMapHasherDefault::hash(VERSION_FULL_CONFIG));
  300. List<StringName> names;
  301. const StringName *k = nullptr;
  302. while ((k = classes.next(k))) {
  303. names.push_back(*k);
  304. }
  305. //must be alphabetically sorted for hash to compute
  306. names.sort_custom<StringName::AlphCompare>();
  307. for (const StringName &E : names) {
  308. ClassInfo *t = classes.getptr(E);
  309. ERR_FAIL_COND_V_MSG(!t, 0, "Cannot get class '" + String(E) + "'.");
  310. if (t->api != p_api || !t->exposed) {
  311. continue;
  312. }
  313. hash = hash_djb2_one_64(t->name.hash(), hash);
  314. hash = hash_djb2_one_64(t->inherits.hash(), hash);
  315. { //methods
  316. List<StringName> snames;
  317. k = nullptr;
  318. while ((k = t->method_map.next(k))) {
  319. String name = k->operator String();
  320. ERR_CONTINUE(name.is_empty());
  321. if (name[0] == '_') {
  322. continue; // Ignore non-virtual methods that start with an underscore
  323. }
  324. snames.push_back(*k);
  325. }
  326. snames.sort_custom<StringName::AlphCompare>();
  327. for (const StringName &F : snames) {
  328. MethodBind *mb = t->method_map[F];
  329. hash = hash_djb2_one_64(mb->get_name().hash(), hash);
  330. hash = hash_djb2_one_64(mb->get_argument_count(), hash);
  331. hash = hash_djb2_one_64(mb->get_argument_type(-1), hash); //return
  332. for (int i = 0; i < mb->get_argument_count(); i++) {
  333. const PropertyInfo info = mb->get_argument_info(i);
  334. hash = hash_djb2_one_64(info.type, hash);
  335. hash = hash_djb2_one_64(info.name.hash(), hash);
  336. hash = hash_djb2_one_64(info.hint, hash);
  337. hash = hash_djb2_one_64(info.hint_string.hash(), hash);
  338. }
  339. hash = hash_djb2_one_64(mb->get_default_argument_count(), hash);
  340. for (int i = 0; i < mb->get_default_argument_count(); i++) {
  341. //hash should not change, i hope for tis
  342. Variant da = mb->get_default_argument(i);
  343. hash = hash_djb2_one_64(da.hash(), hash);
  344. }
  345. hash = hash_djb2_one_64(mb->get_hint_flags(), hash);
  346. }
  347. }
  348. { //constants
  349. List<StringName> snames;
  350. k = nullptr;
  351. while ((k = t->constant_map.next(k))) {
  352. snames.push_back(*k);
  353. }
  354. snames.sort_custom<StringName::AlphCompare>();
  355. for (const StringName &F : snames) {
  356. hash = hash_djb2_one_64(F.hash(), hash);
  357. hash = hash_djb2_one_64(t->constant_map[F], hash);
  358. }
  359. }
  360. { //signals
  361. List<StringName> snames;
  362. k = nullptr;
  363. while ((k = t->signal_map.next(k))) {
  364. snames.push_back(*k);
  365. }
  366. snames.sort_custom<StringName::AlphCompare>();
  367. for (const StringName &F : snames) {
  368. MethodInfo &mi = t->signal_map[F];
  369. hash = hash_djb2_one_64(F.hash(), hash);
  370. for (int i = 0; i < mi.arguments.size(); i++) {
  371. hash = hash_djb2_one_64(mi.arguments[i].type, hash);
  372. }
  373. }
  374. }
  375. { //properties
  376. List<StringName> snames;
  377. k = nullptr;
  378. while ((k = t->property_setget.next(k))) {
  379. snames.push_back(*k);
  380. }
  381. snames.sort_custom<StringName::AlphCompare>();
  382. for (const StringName &F : snames) {
  383. PropertySetGet *psg = t->property_setget.getptr(F);
  384. ERR_FAIL_COND_V(!psg, 0);
  385. hash = hash_djb2_one_64(F.hash(), hash);
  386. hash = hash_djb2_one_64(psg->setter.hash(), hash);
  387. hash = hash_djb2_one_64(psg->getter.hash(), hash);
  388. }
  389. }
  390. //property list
  391. for (const PropertyInfo &F : t->property_list) {
  392. hash = hash_djb2_one_64(F.name.hash(), hash);
  393. hash = hash_djb2_one_64(F.type, hash);
  394. hash = hash_djb2_one_64(F.hint, hash);
  395. hash = hash_djb2_one_64(F.hint_string.hash(), hash);
  396. hash = hash_djb2_one_64(F.usage, hash);
  397. }
  398. }
  399. return hash;
  400. #else
  401. return 0;
  402. #endif
  403. }
  404. bool ClassDB::class_exists(const StringName &p_class) {
  405. OBJTYPE_RLOCK;
  406. return classes.has(p_class);
  407. }
  408. void ClassDB::add_compatibility_class(const StringName &p_class, const StringName &p_fallback) {
  409. OBJTYPE_WLOCK;
  410. compat_classes[p_class] = p_fallback;
  411. }
  412. thread_local bool initializing_with_extension = false;
  413. thread_local ObjectNativeExtension *initializing_extension = nullptr;
  414. thread_local GDExtensionClassInstancePtr initializing_extension_instance = nullptr;
  415. void ClassDB::instance_get_native_extension_data(ObjectNativeExtension **r_extension, GDExtensionClassInstancePtr *r_extension_instance, Object *p_base) {
  416. if (initializing_with_extension) {
  417. *r_extension = initializing_extension;
  418. *r_extension_instance = initializing_extension_instance;
  419. initializing_with_extension = false;
  420. initializing_extension->set_object_instance(*r_extension_instance, p_base);
  421. } else {
  422. *r_extension = nullptr;
  423. *r_extension_instance = nullptr;
  424. }
  425. }
  426. Object *ClassDB::instantiate(const StringName &p_class) {
  427. ClassInfo *ti;
  428. {
  429. OBJTYPE_RLOCK;
  430. ti = classes.getptr(p_class);
  431. if (!ti || ti->disabled || !ti->creation_func || (ti->native_extension && !ti->native_extension->create_instance)) {
  432. if (compat_classes.has(p_class)) {
  433. ti = classes.getptr(compat_classes[p_class]);
  434. }
  435. }
  436. ERR_FAIL_COND_V_MSG(!ti, nullptr, "Cannot get class '" + String(p_class) + "'.");
  437. ERR_FAIL_COND_V_MSG(ti->disabled, nullptr, "Class '" + String(p_class) + "' is disabled.");
  438. ERR_FAIL_COND_V(!ti->creation_func, nullptr);
  439. }
  440. #ifdef TOOLS_ENABLED
  441. if (ti->api == API_EDITOR && !Engine::get_singleton()->is_editor_hint()) {
  442. ERR_PRINT("Class '" + String(p_class) + "' can only be instantiated by editor.");
  443. return nullptr;
  444. }
  445. #endif
  446. if (ti->native_extension) {
  447. initializing_with_extension = true;
  448. initializing_extension = ti->native_extension;
  449. initializing_extension_instance = ti->native_extension->create_instance(ti->native_extension->class_userdata);
  450. }
  451. return ti->creation_func();
  452. }
  453. bool ClassDB::can_instantiate(const StringName &p_class) {
  454. OBJTYPE_RLOCK;
  455. ClassInfo *ti = classes.getptr(p_class);
  456. ERR_FAIL_COND_V_MSG(!ti, false, "Cannot get class '" + String(p_class) + "'.");
  457. #ifdef TOOLS_ENABLED
  458. if (ti->api == API_EDITOR && !Engine::get_singleton()->is_editor_hint()) {
  459. return false;
  460. }
  461. #endif
  462. return (!ti->disabled && ti->creation_func != nullptr && !(ti->native_extension && !ti->native_extension->create_instance));
  463. }
  464. void ClassDB::_add_class2(const StringName &p_class, const StringName &p_inherits) {
  465. OBJTYPE_WLOCK;
  466. const StringName &name = p_class;
  467. ERR_FAIL_COND_MSG(classes.has(name), "Class '" + String(p_class) + "' already exists.");
  468. classes[name] = ClassInfo();
  469. ClassInfo &ti = classes[name];
  470. ti.name = name;
  471. ti.inherits = p_inherits;
  472. ti.api = current_api;
  473. if (ti.inherits) {
  474. ERR_FAIL_COND(!classes.has(ti.inherits)); //it MUST be registered.
  475. ti.inherits_ptr = &classes[ti.inherits];
  476. } else {
  477. ti.inherits_ptr = nullptr;
  478. }
  479. }
  480. #ifdef DEBUG_METHODS_ENABLED
  481. static MethodInfo info_from_bind(MethodBind *p_method) {
  482. MethodInfo minfo;
  483. minfo.name = p_method->get_name();
  484. minfo.id = p_method->get_method_id();
  485. for (int i = 0; i < p_method->get_argument_count(); i++) {
  486. minfo.arguments.push_back(p_method->get_argument_info(i));
  487. }
  488. minfo.return_val = p_method->get_return_info();
  489. minfo.flags = p_method->get_hint_flags();
  490. for (int i = 0; i < p_method->get_argument_count(); i++) {
  491. if (p_method->has_default_argument(i)) {
  492. minfo.default_arguments.push_back(p_method->get_default_argument(i));
  493. }
  494. }
  495. return minfo;
  496. }
  497. #endif
  498. void ClassDB::get_method_list(const StringName &p_class, List<MethodInfo> *p_methods, bool p_no_inheritance, bool p_exclude_from_properties) {
  499. OBJTYPE_RLOCK;
  500. ClassInfo *type = classes.getptr(p_class);
  501. while (type) {
  502. if (type->disabled) {
  503. if (p_no_inheritance) {
  504. break;
  505. }
  506. type = type->inherits_ptr;
  507. continue;
  508. }
  509. #ifdef DEBUG_METHODS_ENABLED
  510. for (const MethodInfo &E : type->virtual_methods) {
  511. p_methods->push_back(E);
  512. }
  513. for (const StringName &E : type->method_order) {
  514. if (p_exclude_from_properties && type->methods_in_properties.has(E)) {
  515. continue;
  516. }
  517. MethodBind *method = type->method_map.get(E);
  518. MethodInfo minfo = info_from_bind(method);
  519. p_methods->push_back(minfo);
  520. }
  521. #else
  522. const StringName *K = nullptr;
  523. while ((K = type->method_map.next(K))) {
  524. MethodBind *m = type->method_map[*K];
  525. MethodInfo mi;
  526. mi.name = m->get_name();
  527. p_methods->push_back(mi);
  528. }
  529. #endif
  530. if (p_no_inheritance) {
  531. break;
  532. }
  533. type = type->inherits_ptr;
  534. }
  535. }
  536. bool ClassDB::get_method_info(const StringName &p_class, const StringName &p_method, MethodInfo *r_info, bool p_no_inheritance, bool p_exclude_from_properties) {
  537. OBJTYPE_RLOCK;
  538. ClassInfo *type = classes.getptr(p_class);
  539. while (type) {
  540. if (type->disabled) {
  541. if (p_no_inheritance) {
  542. break;
  543. }
  544. type = type->inherits_ptr;
  545. continue;
  546. }
  547. #ifdef DEBUG_METHODS_ENABLED
  548. MethodBind **method = type->method_map.getptr(p_method);
  549. if (method && *method) {
  550. if (r_info != nullptr) {
  551. MethodInfo minfo = info_from_bind(*method);
  552. *r_info = minfo;
  553. }
  554. return true;
  555. } else if (type->virtual_methods_map.has(p_method)) {
  556. if (r_info) {
  557. *r_info = type->virtual_methods_map[p_method];
  558. }
  559. return true;
  560. }
  561. #else
  562. if (type->method_map.has(p_method)) {
  563. if (r_info) {
  564. MethodBind *m = type->method_map[p_method];
  565. MethodInfo mi;
  566. mi.name = m->get_name();
  567. *r_info = mi;
  568. }
  569. return true;
  570. }
  571. #endif
  572. if (p_no_inheritance) {
  573. break;
  574. }
  575. type = type->inherits_ptr;
  576. }
  577. return false;
  578. }
  579. MethodBind *ClassDB::get_method(const StringName &p_class, const StringName &p_name) {
  580. OBJTYPE_RLOCK;
  581. ClassInfo *type = classes.getptr(p_class);
  582. while (type) {
  583. MethodBind **method = type->method_map.getptr(p_name);
  584. if (method && *method) {
  585. return *method;
  586. }
  587. type = type->inherits_ptr;
  588. }
  589. return nullptr;
  590. }
  591. void ClassDB::bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int p_constant) {
  592. OBJTYPE_WLOCK;
  593. ClassInfo *type = classes.getptr(p_class);
  594. ERR_FAIL_COND(!type);
  595. if (type->constant_map.has(p_name)) {
  596. ERR_FAIL();
  597. }
  598. type->constant_map[p_name] = p_constant;
  599. String enum_name = p_enum;
  600. if (enum_name != String()) {
  601. if (enum_name.find(".") != -1) {
  602. enum_name = enum_name.get_slicec('.', 1);
  603. }
  604. List<StringName> *constants_list = type->enum_map.getptr(enum_name);
  605. if (constants_list) {
  606. constants_list->push_back(p_name);
  607. } else {
  608. List<StringName> new_list;
  609. new_list.push_back(p_name);
  610. type->enum_map[enum_name] = new_list;
  611. }
  612. }
  613. #ifdef DEBUG_METHODS_ENABLED
  614. type->constant_order.push_back(p_name);
  615. #endif
  616. }
  617. void ClassDB::get_integer_constant_list(const StringName &p_class, List<String> *p_constants, bool p_no_inheritance) {
  618. OBJTYPE_RLOCK;
  619. ClassInfo *type = classes.getptr(p_class);
  620. while (type) {
  621. #ifdef DEBUG_METHODS_ENABLED
  622. for (const StringName &E : type->constant_order) {
  623. p_constants->push_back(E);
  624. }
  625. #else
  626. const StringName *K = nullptr;
  627. while ((K = type->constant_map.next(K))) {
  628. p_constants->push_back(*K);
  629. }
  630. #endif
  631. if (p_no_inheritance) {
  632. break;
  633. }
  634. type = type->inherits_ptr;
  635. }
  636. }
  637. int ClassDB::get_integer_constant(const StringName &p_class, const StringName &p_name, bool *p_success) {
  638. OBJTYPE_RLOCK;
  639. ClassInfo *type = classes.getptr(p_class);
  640. while (type) {
  641. int *constant = type->constant_map.getptr(p_name);
  642. if (constant) {
  643. if (p_success) {
  644. *p_success = true;
  645. }
  646. return *constant;
  647. }
  648. type = type->inherits_ptr;
  649. }
  650. if (p_success) {
  651. *p_success = false;
  652. }
  653. return 0;
  654. }
  655. bool ClassDB::has_integer_constant(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) {
  656. OBJTYPE_RLOCK;
  657. ClassInfo *type = classes.getptr(p_class);
  658. while (type) {
  659. if (type->constant_map.has(p_name)) {
  660. return true;
  661. }
  662. if (p_no_inheritance) {
  663. return false;
  664. }
  665. type = type->inherits_ptr;
  666. }
  667. return false;
  668. }
  669. StringName ClassDB::get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) {
  670. OBJTYPE_RLOCK;
  671. ClassInfo *type = classes.getptr(p_class);
  672. while (type) {
  673. const StringName *k = nullptr;
  674. while ((k = type->enum_map.next(k))) {
  675. List<StringName> &constants_list = type->enum_map.get(*k);
  676. const List<StringName>::Element *found = constants_list.find(p_name);
  677. if (found) {
  678. return *k;
  679. }
  680. }
  681. if (p_no_inheritance) {
  682. break;
  683. }
  684. type = type->inherits_ptr;
  685. }
  686. return StringName();
  687. }
  688. void ClassDB::get_enum_list(const StringName &p_class, List<StringName> *p_enums, bool p_no_inheritance) {
  689. OBJTYPE_RLOCK;
  690. ClassInfo *type = classes.getptr(p_class);
  691. while (type) {
  692. const StringName *k = nullptr;
  693. while ((k = type->enum_map.next(k))) {
  694. p_enums->push_back(*k);
  695. }
  696. if (p_no_inheritance) {
  697. break;
  698. }
  699. type = type->inherits_ptr;
  700. }
  701. }
  702. void ClassDB::get_enum_constants(const StringName &p_class, const StringName &p_enum, List<StringName> *p_constants, bool p_no_inheritance) {
  703. OBJTYPE_RLOCK;
  704. ClassInfo *type = classes.getptr(p_class);
  705. while (type) {
  706. const List<StringName> *constants = type->enum_map.getptr(p_enum);
  707. if (constants) {
  708. for (const List<StringName>::Element *E = constants->front(); E; E = E->next()) {
  709. p_constants->push_back(E->get());
  710. }
  711. }
  712. if (p_no_inheritance) {
  713. break;
  714. }
  715. type = type->inherits_ptr;
  716. }
  717. }
  718. void ClassDB::set_method_error_return_values(const StringName &p_class, const StringName &p_method, const Vector<Error> &p_values) {
  719. OBJTYPE_RLOCK;
  720. #ifdef DEBUG_METHODS_ENABLED
  721. ClassInfo *type = classes.getptr(p_class);
  722. ERR_FAIL_COND(!type);
  723. type->method_error_values[p_method] = p_values;
  724. #endif
  725. }
  726. Vector<Error> ClassDB::get_method_error_return_values(const StringName &p_class, const StringName &p_method) {
  727. #ifdef DEBUG_METHODS_ENABLED
  728. ClassInfo *type = classes.getptr(p_class);
  729. ERR_FAIL_COND_V(!type, Vector<Error>());
  730. if (!type->method_error_values.has(p_method)) {
  731. return Vector<Error>();
  732. }
  733. return type->method_error_values[p_method];
  734. #else
  735. return Vector<Error>();
  736. #endif
  737. }
  738. bool ClassDB::has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) {
  739. OBJTYPE_RLOCK;
  740. ClassInfo *type = classes.getptr(p_class);
  741. while (type) {
  742. if (type->enum_map.has(p_name)) {
  743. return true;
  744. }
  745. if (p_no_inheritance) {
  746. return false;
  747. }
  748. type = type->inherits_ptr;
  749. }
  750. return false;
  751. }
  752. void ClassDB::add_signal(const StringName &p_class, const MethodInfo &p_signal) {
  753. OBJTYPE_WLOCK;
  754. ClassInfo *type = classes.getptr(p_class);
  755. ERR_FAIL_COND(!type);
  756. StringName sname = p_signal.name;
  757. #ifdef DEBUG_METHODS_ENABLED
  758. ClassInfo *check = type;
  759. while (check) {
  760. ERR_FAIL_COND_MSG(check->signal_map.has(sname), "Class '" + String(p_class) + "' already has signal '" + String(sname) + "'.");
  761. check = check->inherits_ptr;
  762. }
  763. #endif
  764. type->signal_map[sname] = p_signal;
  765. }
  766. void ClassDB::get_signal_list(const StringName &p_class, List<MethodInfo> *p_signals, bool p_no_inheritance) {
  767. OBJTYPE_RLOCK;
  768. ClassInfo *type = classes.getptr(p_class);
  769. ERR_FAIL_COND(!type);
  770. ClassInfo *check = type;
  771. while (check) {
  772. const StringName *S = nullptr;
  773. while ((S = check->signal_map.next(S))) {
  774. p_signals->push_back(check->signal_map[*S]);
  775. }
  776. if (p_no_inheritance) {
  777. return;
  778. }
  779. check = check->inherits_ptr;
  780. }
  781. }
  782. bool ClassDB::has_signal(const StringName &p_class, const StringName &p_signal, bool p_no_inheritance) {
  783. OBJTYPE_RLOCK;
  784. ClassInfo *type = classes.getptr(p_class);
  785. ClassInfo *check = type;
  786. while (check) {
  787. if (check->signal_map.has(p_signal)) {
  788. return true;
  789. }
  790. if (p_no_inheritance) {
  791. return false;
  792. }
  793. check = check->inherits_ptr;
  794. }
  795. return false;
  796. }
  797. bool ClassDB::get_signal(const StringName &p_class, const StringName &p_signal, MethodInfo *r_signal) {
  798. OBJTYPE_RLOCK;
  799. ClassInfo *type = classes.getptr(p_class);
  800. ClassInfo *check = type;
  801. while (check) {
  802. if (check->signal_map.has(p_signal)) {
  803. if (r_signal) {
  804. *r_signal = check->signal_map[p_signal];
  805. }
  806. return true;
  807. }
  808. check = check->inherits_ptr;
  809. }
  810. return false;
  811. }
  812. void ClassDB::add_property_group(const StringName &p_class, const String &p_name, const String &p_prefix) {
  813. OBJTYPE_WLOCK;
  814. ClassInfo *type = classes.getptr(p_class);
  815. ERR_FAIL_COND(!type);
  816. type->property_list.push_back(PropertyInfo(Variant::NIL, p_name, PROPERTY_HINT_NONE, p_prefix, PROPERTY_USAGE_GROUP));
  817. }
  818. void ClassDB::add_property_subgroup(const StringName &p_class, const String &p_name, const String &p_prefix) {
  819. OBJTYPE_WLOCK;
  820. ClassInfo *type = classes.getptr(p_class);
  821. ERR_FAIL_COND(!type);
  822. type->property_list.push_back(PropertyInfo(Variant::NIL, p_name, PROPERTY_HINT_NONE, p_prefix, PROPERTY_USAGE_SUBGROUP));
  823. }
  824. // NOTE: For implementation simplicity reasons, this method doesn't allow setters to have optional arguments at the end.
  825. void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinfo, const StringName &p_setter, const StringName &p_getter, int p_index) {
  826. lock.read_lock();
  827. ClassInfo *type = classes.getptr(p_class);
  828. lock.read_unlock();
  829. ERR_FAIL_COND(!type);
  830. MethodBind *mb_set = nullptr;
  831. if (p_setter) {
  832. mb_set = get_method(p_class, p_setter);
  833. #ifdef DEBUG_METHODS_ENABLED
  834. ERR_FAIL_COND_MSG(!mb_set, "Invalid setter '" + p_class + "::" + p_setter + "' for property '" + p_pinfo.name + "'.");
  835. int exp_args = 1 + (p_index >= 0 ? 1 : 0);
  836. ERR_FAIL_COND_MSG(mb_set->get_argument_count() != exp_args, "Invalid function for setter '" + p_class + "::" + p_setter + " for property '" + p_pinfo.name + "'.");
  837. #endif
  838. }
  839. MethodBind *mb_get = nullptr;
  840. if (p_getter) {
  841. mb_get = get_method(p_class, p_getter);
  842. #ifdef DEBUG_METHODS_ENABLED
  843. ERR_FAIL_COND_MSG(!mb_get, "Invalid getter '" + p_class + "::" + p_getter + "' for property '" + p_pinfo.name + "'.");
  844. int exp_args = 0 + (p_index >= 0 ? 1 : 0);
  845. ERR_FAIL_COND_MSG(mb_get->get_argument_count() != exp_args, "Invalid function for getter '" + p_class + "::" + p_getter + "' for property: '" + p_pinfo.name + "'.");
  846. #endif
  847. }
  848. #ifdef DEBUG_METHODS_ENABLED
  849. ERR_FAIL_COND_MSG(type->property_setget.has(p_pinfo.name), "Object '" + p_class + "' already has property '" + p_pinfo.name + "'.");
  850. #endif
  851. OBJTYPE_WLOCK
  852. type->property_list.push_back(p_pinfo);
  853. type->property_map[p_pinfo.name] = p_pinfo;
  854. #ifdef DEBUG_METHODS_ENABLED
  855. if (mb_get) {
  856. type->methods_in_properties.insert(p_getter);
  857. }
  858. if (mb_set) {
  859. type->methods_in_properties.insert(p_setter);
  860. }
  861. #endif
  862. PropertySetGet psg;
  863. psg.setter = p_setter;
  864. psg.getter = p_getter;
  865. psg._setptr = mb_set;
  866. psg._getptr = mb_get;
  867. psg.index = p_index;
  868. psg.type = p_pinfo.type;
  869. type->property_setget[p_pinfo.name] = psg;
  870. }
  871. void ClassDB::set_property_default_value(const StringName &p_class, const StringName &p_name, const Variant &p_default) {
  872. if (!default_values.has(p_class)) {
  873. default_values[p_class] = HashMap<StringName, Variant>();
  874. }
  875. default_values[p_class][p_name] = p_default;
  876. }
  877. void ClassDB::add_linked_property(const StringName &p_class, const String &p_property, const String &p_linked_property) {
  878. #ifdef TOOLS_ENABLED
  879. OBJTYPE_WLOCK;
  880. ClassInfo *type = classes.getptr(p_class);
  881. ERR_FAIL_COND(!type);
  882. ERR_FAIL_COND(!type->property_map.has(p_property));
  883. ERR_FAIL_COND(!type->property_map.has(p_linked_property));
  884. PropertyInfo &pinfo = type->property_map[p_property];
  885. pinfo.linked_properties.push_back(p_linked_property);
  886. #endif
  887. }
  888. void ClassDB::get_property_list(const StringName &p_class, List<PropertyInfo> *p_list, bool p_no_inheritance, const Object *p_validator) {
  889. OBJTYPE_RLOCK;
  890. ClassInfo *type = classes.getptr(p_class);
  891. ClassInfo *check = type;
  892. while (check) {
  893. for (const PropertyInfo &pi : check->property_list) {
  894. if (p_validator) {
  895. // Making a copy as we may modify it.
  896. PropertyInfo pi_mut = pi;
  897. p_validator->_validate_property(pi_mut);
  898. p_list->push_back(pi_mut);
  899. } else {
  900. p_list->push_back(pi);
  901. }
  902. }
  903. if (p_no_inheritance) {
  904. return;
  905. }
  906. check = check->inherits_ptr;
  907. }
  908. }
  909. bool ClassDB::get_property_info(const StringName &p_class, const StringName &p_property, PropertyInfo *r_info, bool p_no_inheritance, const Object *p_validator) {
  910. OBJTYPE_RLOCK;
  911. ClassInfo *check = classes.getptr(p_class);
  912. while (check) {
  913. if (check->property_map.has(p_property)) {
  914. PropertyInfo pinfo = check->property_map[p_property];
  915. if (p_validator) {
  916. p_validator->_validate_property(pinfo);
  917. }
  918. if (r_info) {
  919. *r_info = pinfo;
  920. }
  921. return true;
  922. }
  923. if (p_no_inheritance) {
  924. break;
  925. }
  926. check = check->inherits_ptr;
  927. }
  928. return false;
  929. }
  930. bool ClassDB::set_property(Object *p_object, const StringName &p_property, const Variant &p_value, bool *r_valid) {
  931. ERR_FAIL_NULL_V(p_object, false);
  932. ClassInfo *type = classes.getptr(p_object->get_class_name());
  933. ClassInfo *check = type;
  934. while (check) {
  935. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  936. if (psg) {
  937. if (!psg->setter) {
  938. if (r_valid) {
  939. *r_valid = false;
  940. }
  941. return true; //return true but do nothing
  942. }
  943. Callable::CallError ce;
  944. if (psg->index >= 0) {
  945. Variant index = psg->index;
  946. const Variant *arg[2] = { &index, &p_value };
  947. //p_object->call(psg->setter,arg,2,ce);
  948. if (psg->_setptr) {
  949. psg->_setptr->call(p_object, arg, 2, ce);
  950. } else {
  951. p_object->call(psg->setter, arg, 2, ce);
  952. }
  953. } else {
  954. const Variant *arg[1] = { &p_value };
  955. if (psg->_setptr) {
  956. psg->_setptr->call(p_object, arg, 1, ce);
  957. } else {
  958. p_object->call(psg->setter, arg, 1, ce);
  959. }
  960. }
  961. if (r_valid) {
  962. *r_valid = ce.error == Callable::CallError::CALL_OK;
  963. }
  964. return true;
  965. }
  966. check = check->inherits_ptr;
  967. }
  968. return false;
  969. }
  970. bool ClassDB::get_property(Object *p_object, const StringName &p_property, Variant &r_value) {
  971. ERR_FAIL_NULL_V(p_object, false);
  972. ClassInfo *type = classes.getptr(p_object->get_class_name());
  973. ClassInfo *check = type;
  974. while (check) {
  975. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  976. if (psg) {
  977. if (!psg->getter) {
  978. return true; //return true but do nothing
  979. }
  980. if (psg->index >= 0) {
  981. Variant index = psg->index;
  982. const Variant *arg[1] = { &index };
  983. Callable::CallError ce;
  984. r_value = p_object->call(psg->getter, arg, 1, ce);
  985. } else {
  986. Callable::CallError ce;
  987. if (psg->_getptr) {
  988. r_value = psg->_getptr->call(p_object, nullptr, 0, ce);
  989. } else {
  990. r_value = p_object->call(psg->getter, nullptr, 0, ce);
  991. }
  992. }
  993. return true;
  994. }
  995. const int *c = check->constant_map.getptr(p_property); //constants count
  996. if (c) {
  997. r_value = *c;
  998. return true;
  999. }
  1000. if (check->method_map.has(p_property)) { //methods count
  1001. r_value = Callable(p_object, p_property);
  1002. return true;
  1003. }
  1004. if (check->signal_map.has(p_property)) { //signals count
  1005. r_value = Signal(p_object, p_property);
  1006. return true;
  1007. }
  1008. check = check->inherits_ptr;
  1009. }
  1010. return false;
  1011. }
  1012. int ClassDB::get_property_index(const StringName &p_class, const StringName &p_property, bool *r_is_valid) {
  1013. ClassInfo *type = classes.getptr(p_class);
  1014. ClassInfo *check = type;
  1015. while (check) {
  1016. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  1017. if (psg) {
  1018. if (r_is_valid) {
  1019. *r_is_valid = true;
  1020. }
  1021. return psg->index;
  1022. }
  1023. check = check->inherits_ptr;
  1024. }
  1025. if (r_is_valid) {
  1026. *r_is_valid = false;
  1027. }
  1028. return -1;
  1029. }
  1030. Variant::Type ClassDB::get_property_type(const StringName &p_class, const StringName &p_property, bool *r_is_valid) {
  1031. ClassInfo *type = classes.getptr(p_class);
  1032. ClassInfo *check = type;
  1033. while (check) {
  1034. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  1035. if (psg) {
  1036. if (r_is_valid) {
  1037. *r_is_valid = true;
  1038. }
  1039. return psg->type;
  1040. }
  1041. check = check->inherits_ptr;
  1042. }
  1043. if (r_is_valid) {
  1044. *r_is_valid = false;
  1045. }
  1046. return Variant::NIL;
  1047. }
  1048. StringName ClassDB::get_property_setter(const StringName &p_class, const StringName &p_property) {
  1049. ClassInfo *type = classes.getptr(p_class);
  1050. ClassInfo *check = type;
  1051. while (check) {
  1052. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  1053. if (psg) {
  1054. return psg->setter;
  1055. }
  1056. check = check->inherits_ptr;
  1057. }
  1058. return StringName();
  1059. }
  1060. StringName ClassDB::get_property_getter(const StringName &p_class, const StringName &p_property) {
  1061. ClassInfo *type = classes.getptr(p_class);
  1062. ClassInfo *check = type;
  1063. while (check) {
  1064. const PropertySetGet *psg = check->property_setget.getptr(p_property);
  1065. if (psg) {
  1066. return psg->getter;
  1067. }
  1068. check = check->inherits_ptr;
  1069. }
  1070. return StringName();
  1071. }
  1072. bool ClassDB::has_property(const StringName &p_class, const StringName &p_property, bool p_no_inheritance) {
  1073. ClassInfo *type = classes.getptr(p_class);
  1074. ClassInfo *check = type;
  1075. while (check) {
  1076. if (check->property_setget.has(p_property)) {
  1077. return true;
  1078. }
  1079. if (p_no_inheritance) {
  1080. break;
  1081. }
  1082. check = check->inherits_ptr;
  1083. }
  1084. return false;
  1085. }
  1086. void ClassDB::set_method_flags(const StringName &p_class, const StringName &p_method, int p_flags) {
  1087. OBJTYPE_WLOCK;
  1088. ClassInfo *type = classes.getptr(p_class);
  1089. ClassInfo *check = type;
  1090. ERR_FAIL_COND(!check);
  1091. ERR_FAIL_COND(!check->method_map.has(p_method));
  1092. check->method_map[p_method]->set_hint_flags(p_flags);
  1093. }
  1094. bool ClassDB::has_method(const StringName &p_class, const StringName &p_method, bool p_no_inheritance) {
  1095. ClassInfo *type = classes.getptr(p_class);
  1096. ClassInfo *check = type;
  1097. while (check) {
  1098. if (check->method_map.has(p_method)) {
  1099. return true;
  1100. }
  1101. if (p_no_inheritance) {
  1102. return false;
  1103. }
  1104. check = check->inherits_ptr;
  1105. }
  1106. return false;
  1107. }
  1108. void ClassDB::bind_method_custom(const StringName &p_class, MethodBind *p_method) {
  1109. ClassInfo *type = classes.getptr(p_class);
  1110. if (!type) {
  1111. ERR_FAIL_MSG("Couldn't bind custom method '" + p_method->get_name() + "' for instance '" + p_class + "'.");
  1112. }
  1113. if (type->method_map.has(p_method->get_name())) {
  1114. // overloading not supported
  1115. ERR_FAIL_MSG("Method already bound '" + p_class + "::" + p_method->get_name() + "'.");
  1116. }
  1117. #ifdef DEBUG_METHODS_ENABLED
  1118. type->method_order.push_back(p_method->get_name());
  1119. #endif
  1120. type->method_map[p_method->get_name()] = p_method;
  1121. }
  1122. #ifdef DEBUG_METHODS_ENABLED
  1123. MethodBind *ClassDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const MethodDefinition &method_name, const Variant **p_defs, int p_defcount) {
  1124. StringName mdname = method_name.name;
  1125. #else
  1126. MethodBind *ClassDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const char *method_name, const Variant **p_defs, int p_defcount) {
  1127. StringName mdname = StaticCString::create(method_name);
  1128. #endif
  1129. OBJTYPE_WLOCK;
  1130. ERR_FAIL_COND_V(!p_bind, nullptr);
  1131. p_bind->set_name(mdname);
  1132. String instance_type = p_bind->get_instance_class();
  1133. #ifdef DEBUG_ENABLED
  1134. ERR_FAIL_COND_V_MSG(has_method(instance_type, mdname), nullptr, "Class " + String(instance_type) + " already has a method " + String(mdname) + ".");
  1135. #endif
  1136. ClassInfo *type = classes.getptr(instance_type);
  1137. if (!type) {
  1138. memdelete(p_bind);
  1139. ERR_FAIL_V_MSG(nullptr, "Couldn't bind method '" + mdname + "' for instance '" + instance_type + "'.");
  1140. }
  1141. if (type->method_map.has(mdname)) {
  1142. memdelete(p_bind);
  1143. // overloading not supported
  1144. ERR_FAIL_V_MSG(nullptr, "Method already bound '" + instance_type + "::" + mdname + "'.");
  1145. }
  1146. #ifdef DEBUG_METHODS_ENABLED
  1147. if (method_name.args.size() > p_bind->get_argument_count()) {
  1148. memdelete(p_bind);
  1149. ERR_FAIL_V_MSG(nullptr, "Method definition provides more arguments than the method actually has '" + instance_type + "::" + mdname + "'.");
  1150. }
  1151. p_bind->set_argument_names(method_name.args);
  1152. type->method_order.push_back(mdname);
  1153. #endif
  1154. type->method_map[mdname] = p_bind;
  1155. Vector<Variant> defvals;
  1156. defvals.resize(p_defcount);
  1157. for (int i = 0; i < p_defcount; i++) {
  1158. defvals.write[i] = *p_defs[i];
  1159. }
  1160. p_bind->set_default_arguments(defvals);
  1161. p_bind->set_hint_flags(p_flags);
  1162. return p_bind;
  1163. }
  1164. void ClassDB::add_virtual_method(const StringName &p_class, const MethodInfo &p_method, bool p_virtual, const Vector<String> &p_arg_names, bool p_object_core) {
  1165. ERR_FAIL_COND_MSG(!classes.has(p_class), "Request for nonexistent class '" + p_class + "'.");
  1166. OBJTYPE_WLOCK;
  1167. #ifdef DEBUG_METHODS_ENABLED
  1168. MethodInfo mi = p_method;
  1169. if (p_virtual) {
  1170. mi.flags |= METHOD_FLAG_VIRTUAL;
  1171. }
  1172. if (p_object_core) {
  1173. mi.flags |= METHOD_FLAG_OBJECT_CORE;
  1174. }
  1175. if (p_arg_names.size()) {
  1176. if (p_arg_names.size() != mi.arguments.size()) {
  1177. WARN_PRINT("Mismatch argument name count for virtual function: " + String(p_class) + "::" + p_method.name);
  1178. } else {
  1179. for (int i = 0; i < p_arg_names.size(); i++) {
  1180. mi.arguments[i].name = p_arg_names[i];
  1181. }
  1182. }
  1183. }
  1184. classes[p_class].virtual_methods.push_back(mi);
  1185. classes[p_class].virtual_methods_map[p_method.name] = mi;
  1186. #endif
  1187. }
  1188. void ClassDB::get_virtual_methods(const StringName &p_class, List<MethodInfo> *p_methods, bool p_no_inheritance) {
  1189. ERR_FAIL_COND_MSG(!classes.has(p_class), "Request for nonexistent class '" + p_class + "'.");
  1190. #ifdef DEBUG_METHODS_ENABLED
  1191. ClassInfo *type = classes.getptr(p_class);
  1192. ClassInfo *check = type;
  1193. while (check) {
  1194. for (const MethodInfo &E : check->virtual_methods) {
  1195. p_methods->push_back(E);
  1196. }
  1197. if (p_no_inheritance) {
  1198. return;
  1199. }
  1200. check = check->inherits_ptr;
  1201. }
  1202. #endif
  1203. }
  1204. void ClassDB::set_class_enabled(const StringName &p_class, bool p_enable) {
  1205. OBJTYPE_WLOCK;
  1206. ERR_FAIL_COND_MSG(!classes.has(p_class), "Request for nonexistent class '" + p_class + "'.");
  1207. classes[p_class].disabled = !p_enable;
  1208. }
  1209. bool ClassDB::is_class_enabled(const StringName &p_class) {
  1210. OBJTYPE_RLOCK;
  1211. ClassInfo *ti = classes.getptr(p_class);
  1212. if (!ti || !ti->creation_func) {
  1213. if (compat_classes.has(p_class)) {
  1214. ti = classes.getptr(compat_classes[p_class]);
  1215. }
  1216. }
  1217. ERR_FAIL_COND_V_MSG(!ti, false, "Cannot get class '" + String(p_class) + "'.");
  1218. return !ti->disabled;
  1219. }
  1220. bool ClassDB::is_class_exposed(const StringName &p_class) {
  1221. OBJTYPE_RLOCK;
  1222. ClassInfo *ti = classes.getptr(p_class);
  1223. ERR_FAIL_COND_V_MSG(!ti, false, "Cannot get class '" + String(p_class) + "'.");
  1224. return ti->exposed;
  1225. }
  1226. StringName ClassDB::get_category(const StringName &p_node) {
  1227. ERR_FAIL_COND_V(!classes.has(p_node), StringName());
  1228. #ifdef DEBUG_ENABLED
  1229. return classes[p_node].category;
  1230. #else
  1231. return StringName();
  1232. #endif
  1233. }
  1234. void ClassDB::add_resource_base_extension(const StringName &p_extension, const StringName &p_class) {
  1235. if (resource_base_extensions.has(p_extension)) {
  1236. return;
  1237. }
  1238. resource_base_extensions[p_extension] = p_class;
  1239. }
  1240. void ClassDB::get_resource_base_extensions(List<String> *p_extensions) {
  1241. const StringName *K = nullptr;
  1242. while ((K = resource_base_extensions.next(K))) {
  1243. p_extensions->push_back(*K);
  1244. }
  1245. }
  1246. bool ClassDB::is_resource_extension(const StringName &p_extension) {
  1247. return resource_base_extensions.has(p_extension);
  1248. }
  1249. void ClassDB::get_extensions_for_type(const StringName &p_class, List<String> *p_extensions) {
  1250. const StringName *K = nullptr;
  1251. while ((K = resource_base_extensions.next(K))) {
  1252. StringName cmp = resource_base_extensions[*K];
  1253. if (is_parent_class(p_class, cmp) || is_parent_class(cmp, p_class)) {
  1254. p_extensions->push_back(*K);
  1255. }
  1256. }
  1257. }
  1258. HashMap<StringName, HashMap<StringName, Variant>> ClassDB::default_values;
  1259. Set<StringName> ClassDB::default_values_cached;
  1260. Variant ClassDB::class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid) {
  1261. if (!default_values_cached.has(p_class)) {
  1262. if (!default_values.has(p_class)) {
  1263. default_values[p_class] = HashMap<StringName, Variant>();
  1264. }
  1265. Object *c = nullptr;
  1266. bool cleanup_c = false;
  1267. if (Engine::get_singleton()->has_singleton(p_class)) {
  1268. c = Engine::get_singleton()->get_singleton_object(p_class);
  1269. cleanup_c = false;
  1270. } else if (ClassDB::can_instantiate(p_class)) {
  1271. c = ClassDB::instantiate(p_class);
  1272. cleanup_c = true;
  1273. }
  1274. if (c) {
  1275. List<PropertyInfo> plist;
  1276. c->get_property_list(&plist);
  1277. for (const PropertyInfo &E : plist) {
  1278. if (E.usage & (PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR)) {
  1279. if (!default_values[p_class].has(E.name)) {
  1280. Variant v = c->get(E.name);
  1281. default_values[p_class][E.name] = v;
  1282. }
  1283. }
  1284. }
  1285. if (cleanup_c) {
  1286. memdelete(c);
  1287. }
  1288. }
  1289. default_values_cached.insert(p_class);
  1290. }
  1291. if (!default_values.has(p_class)) {
  1292. if (r_valid != nullptr) {
  1293. *r_valid = false;
  1294. }
  1295. return Variant();
  1296. }
  1297. if (!default_values[p_class].has(p_property)) {
  1298. if (r_valid != nullptr) {
  1299. *r_valid = false;
  1300. }
  1301. return Variant();
  1302. }
  1303. if (r_valid != nullptr) {
  1304. *r_valid = true;
  1305. }
  1306. Variant var = default_values[p_class][p_property];
  1307. #ifdef DEBUG_ENABLED
  1308. // Some properties may have an instantiated Object as default value,
  1309. // (like Path2D's `curve` used to have), but that's not a good practice.
  1310. // Instead, those properties should use PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT
  1311. // to be auto-instantiated when created in the editor.
  1312. if (var.get_type() == Variant::OBJECT) {
  1313. Object *obj = var.get_validated_object();
  1314. if (obj) {
  1315. WARN_PRINT(vformat("Instantiated %s used as default value for %s's \"%s\" property.", obj->get_class(), p_class, p_property));
  1316. }
  1317. }
  1318. #endif
  1319. return var;
  1320. }
  1321. void ClassDB::register_extension_class(ObjectNativeExtension *p_extension) {
  1322. GLOBAL_LOCK_FUNCTION;
  1323. ERR_FAIL_COND_MSG(classes.has(p_extension->class_name), "Class already registered: " + String(p_extension->class_name));
  1324. ERR_FAIL_COND_MSG(!classes.has(p_extension->parent_class_name), "Parent class name for extension class not found: " + String(p_extension->parent_class_name));
  1325. ClassInfo *parent = classes.getptr(p_extension->parent_class_name);
  1326. ClassInfo c;
  1327. c.api = p_extension->editor_class ? API_EDITOR_EXTENSION : API_EXTENSION;
  1328. c.native_extension = p_extension;
  1329. c.name = p_extension->class_name;
  1330. c.creation_func = parent->creation_func;
  1331. c.inherits = parent->name;
  1332. c.class_ptr = parent->class_ptr;
  1333. c.inherits_ptr = parent;
  1334. c.exposed = true;
  1335. classes[p_extension->class_name] = c;
  1336. }
  1337. void ClassDB::unregister_extension_class(const StringName &p_class) {
  1338. ERR_FAIL_COND(!classes.has(p_class));
  1339. classes.erase(p_class);
  1340. }
  1341. RWLock ClassDB::lock;
  1342. void ClassDB::cleanup_defaults() {
  1343. default_values.clear();
  1344. default_values_cached.clear();
  1345. }
  1346. void ClassDB::cleanup() {
  1347. //OBJTYPE_LOCK; hah not here
  1348. const StringName *k = nullptr;
  1349. while ((k = classes.next(k))) {
  1350. ClassInfo &ti = classes[*k];
  1351. const StringName *m = nullptr;
  1352. while ((m = ti.method_map.next(m))) {
  1353. memdelete(ti.method_map[*m]);
  1354. }
  1355. }
  1356. classes.clear();
  1357. resource_base_extensions.clear();
  1358. compat_classes.clear();
  1359. }
  1360. //