gd_functions.cpp 43 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736
  1. /*************************************************************************/
  2. /* gd_functions.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2017 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_functions.h"
  31. #include "class_db.h"
  32. #include "func_ref.h"
  33. #include "gd_script.h"
  34. #include "io/json.h"
  35. #include "io/marshalls.h"
  36. #include "math_funcs.h"
  37. #include "os/os.h"
  38. #include "reference.h"
  39. #include "variant_parser.h"
  40. const char *GDFunctions::get_func_name(Function p_func) {
  41. ERR_FAIL_INDEX_V(p_func, FUNC_MAX, "");
  42. static const char *_names[FUNC_MAX] = {
  43. "sin",
  44. "cos",
  45. "tan",
  46. "sinh",
  47. "cosh",
  48. "tanh",
  49. "asin",
  50. "acos",
  51. "atan",
  52. "atan2",
  53. "sqrt",
  54. "fmod",
  55. "fposmod",
  56. "floor",
  57. "ceil",
  58. "round",
  59. "abs",
  60. "sign",
  61. "pow",
  62. "log",
  63. "exp",
  64. "is_nan",
  65. "is_inf",
  66. "ease",
  67. "decimals",
  68. "stepify",
  69. "lerp",
  70. "inverse_lerp",
  71. "range_lerp",
  72. "dectime",
  73. "randomize",
  74. "randi",
  75. "randf",
  76. "rand_range",
  77. "seed",
  78. "rand_seed",
  79. "deg2rad",
  80. "rad2deg",
  81. "linear2db",
  82. "db2linear",
  83. "max",
  84. "min",
  85. "clamp",
  86. "nearest_po2",
  87. "weakref",
  88. "funcref",
  89. "convert",
  90. "typeof",
  91. "type_exists",
  92. "char",
  93. "str",
  94. "print",
  95. "printt",
  96. "prints",
  97. "printerr",
  98. "printraw",
  99. "var2str",
  100. "str2var",
  101. "var2bytes",
  102. "bytes2var",
  103. "range",
  104. "load",
  105. "inst2dict",
  106. "dict2inst",
  107. "validate_json",
  108. "parse_json",
  109. "to_json",
  110. "hash",
  111. "Color8",
  112. "ColorN",
  113. "print_stack",
  114. "instance_from_id",
  115. "len",
  116. };
  117. return _names[p_func];
  118. }
  119. void GDFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) {
  120. r_error.error = Variant::CallError::CALL_OK;
  121. #ifdef DEBUG_ENABLED
  122. #define VALIDATE_ARG_COUNT(m_count) \
  123. if (p_arg_count < m_count) { \
  124. r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS; \
  125. r_error.argument = m_count; \
  126. r_ret = Variant(); \
  127. return; \
  128. } \
  129. if (p_arg_count > m_count) { \
  130. r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; \
  131. r_error.argument = m_count; \
  132. r_ret = Variant(); \
  133. return; \
  134. }
  135. #define VALIDATE_ARG_NUM(m_arg) \
  136. if (!p_args[m_arg]->is_num()) { \
  137. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
  138. r_error.argument = m_arg; \
  139. r_error.expected = Variant::REAL; \
  140. r_ret = Variant(); \
  141. return; \
  142. }
  143. #else
  144. #define VALIDATE_ARG_COUNT(m_count)
  145. #define VALIDATE_ARG_NUM(m_arg)
  146. #endif
  147. //using a switch, so the compiler generates a jumptable
  148. switch (p_func) {
  149. case MATH_SIN: {
  150. VALIDATE_ARG_COUNT(1);
  151. VALIDATE_ARG_NUM(0);
  152. r_ret = Math::sin((double)*p_args[0]);
  153. } break;
  154. case MATH_COS: {
  155. VALIDATE_ARG_COUNT(1);
  156. VALIDATE_ARG_NUM(0);
  157. r_ret = Math::cos((double)*p_args[0]);
  158. } break;
  159. case MATH_TAN: {
  160. VALIDATE_ARG_COUNT(1);
  161. VALIDATE_ARG_NUM(0);
  162. r_ret = Math::tan((double)*p_args[0]);
  163. } break;
  164. case MATH_SINH: {
  165. VALIDATE_ARG_COUNT(1);
  166. VALIDATE_ARG_NUM(0);
  167. r_ret = Math::sinh((double)*p_args[0]);
  168. } break;
  169. case MATH_COSH: {
  170. VALIDATE_ARG_COUNT(1);
  171. VALIDATE_ARG_NUM(0);
  172. r_ret = Math::cosh((double)*p_args[0]);
  173. } break;
  174. case MATH_TANH: {
  175. VALIDATE_ARG_COUNT(1);
  176. VALIDATE_ARG_NUM(0);
  177. r_ret = Math::tanh((double)*p_args[0]);
  178. } break;
  179. case MATH_ASIN: {
  180. VALIDATE_ARG_COUNT(1);
  181. VALIDATE_ARG_NUM(0);
  182. r_ret = Math::asin((double)*p_args[0]);
  183. } break;
  184. case MATH_ACOS: {
  185. VALIDATE_ARG_COUNT(1);
  186. VALIDATE_ARG_NUM(0);
  187. r_ret = Math::acos((double)*p_args[0]);
  188. } break;
  189. case MATH_ATAN: {
  190. VALIDATE_ARG_COUNT(1);
  191. VALIDATE_ARG_NUM(0);
  192. r_ret = Math::atan((double)*p_args[0]);
  193. } break;
  194. case MATH_ATAN2: {
  195. VALIDATE_ARG_COUNT(2);
  196. VALIDATE_ARG_NUM(0);
  197. VALIDATE_ARG_NUM(1);
  198. r_ret = Math::atan2((double)*p_args[0], (double)*p_args[1]);
  199. } break;
  200. case MATH_SQRT: {
  201. VALIDATE_ARG_COUNT(1);
  202. VALIDATE_ARG_NUM(0);
  203. r_ret = Math::sqrt((double)*p_args[0]);
  204. } break;
  205. case MATH_FMOD: {
  206. VALIDATE_ARG_COUNT(2);
  207. VALIDATE_ARG_NUM(0);
  208. VALIDATE_ARG_NUM(1);
  209. r_ret = Math::fmod((double)*p_args[0], (double)*p_args[1]);
  210. } break;
  211. case MATH_FPOSMOD: {
  212. VALIDATE_ARG_COUNT(2);
  213. VALIDATE_ARG_NUM(0);
  214. VALIDATE_ARG_NUM(1);
  215. r_ret = Math::fposmod((double)*p_args[0], (double)*p_args[1]);
  216. } break;
  217. case MATH_FLOOR: {
  218. VALIDATE_ARG_COUNT(1);
  219. VALIDATE_ARG_NUM(0);
  220. r_ret = Math::floor((double)*p_args[0]);
  221. } break;
  222. case MATH_CEIL: {
  223. VALIDATE_ARG_COUNT(1);
  224. VALIDATE_ARG_NUM(0);
  225. r_ret = Math::ceil((double)*p_args[0]);
  226. } break;
  227. case MATH_ROUND: {
  228. VALIDATE_ARG_COUNT(1);
  229. VALIDATE_ARG_NUM(0);
  230. r_ret = Math::round((double)*p_args[0]);
  231. } break;
  232. case MATH_ABS: {
  233. VALIDATE_ARG_COUNT(1);
  234. if (p_args[0]->get_type() == Variant::INT) {
  235. int64_t i = *p_args[0];
  236. r_ret = ABS(i);
  237. } else if (p_args[0]->get_type() == Variant::REAL) {
  238. double r = *p_args[0];
  239. r_ret = Math::abs(r);
  240. } else {
  241. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  242. r_error.argument = 0;
  243. r_error.expected = Variant::REAL;
  244. r_ret = Variant();
  245. }
  246. } break;
  247. case MATH_SIGN: {
  248. VALIDATE_ARG_COUNT(1);
  249. if (p_args[0]->get_type() == Variant::INT) {
  250. int64_t i = *p_args[0];
  251. r_ret = i < 0 ? -1 : (i > 0 ? +1 : 0);
  252. } else if (p_args[0]->get_type() == Variant::REAL) {
  253. real_t r = *p_args[0];
  254. r_ret = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
  255. } else {
  256. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  257. r_error.argument = 0;
  258. r_error.expected = Variant::REAL;
  259. r_ret = Variant();
  260. }
  261. } break;
  262. case MATH_POW: {
  263. VALIDATE_ARG_COUNT(2);
  264. VALIDATE_ARG_NUM(0);
  265. VALIDATE_ARG_NUM(1);
  266. r_ret = Math::pow((double)*p_args[0], (double)*p_args[1]);
  267. } break;
  268. case MATH_LOG: {
  269. VALIDATE_ARG_COUNT(1);
  270. VALIDATE_ARG_NUM(0);
  271. r_ret = Math::log((double)*p_args[0]);
  272. } break;
  273. case MATH_EXP: {
  274. VALIDATE_ARG_COUNT(1);
  275. VALIDATE_ARG_NUM(0);
  276. r_ret = Math::exp((double)*p_args[0]);
  277. } break;
  278. case MATH_ISNAN: {
  279. VALIDATE_ARG_COUNT(1);
  280. VALIDATE_ARG_NUM(0);
  281. r_ret = Math::is_nan((double)*p_args[0]);
  282. } break;
  283. case MATH_ISINF: {
  284. VALIDATE_ARG_COUNT(1);
  285. VALIDATE_ARG_NUM(0);
  286. r_ret = Math::is_inf((double)*p_args[0]);
  287. } break;
  288. case MATH_EASE: {
  289. VALIDATE_ARG_COUNT(2);
  290. VALIDATE_ARG_NUM(0);
  291. VALIDATE_ARG_NUM(1);
  292. r_ret = Math::ease((double)*p_args[0], (double)*p_args[1]);
  293. } break;
  294. case MATH_DECIMALS: {
  295. VALIDATE_ARG_COUNT(1);
  296. VALIDATE_ARG_NUM(0);
  297. r_ret = Math::step_decimals((double)*p_args[0]);
  298. } break;
  299. case MATH_STEPIFY: {
  300. VALIDATE_ARG_COUNT(2);
  301. VALIDATE_ARG_NUM(0);
  302. VALIDATE_ARG_NUM(1);
  303. r_ret = Math::stepify((double)*p_args[0], (double)*p_args[1]);
  304. } break;
  305. case MATH_LERP: {
  306. VALIDATE_ARG_COUNT(3);
  307. VALIDATE_ARG_NUM(0);
  308. VALIDATE_ARG_NUM(1);
  309. VALIDATE_ARG_NUM(2);
  310. r_ret = Math::lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
  311. } break;
  312. case MATH_INVERSE_LERP: {
  313. VALIDATE_ARG_COUNT(3);
  314. VALIDATE_ARG_NUM(0);
  315. VALIDATE_ARG_NUM(1);
  316. VALIDATE_ARG_NUM(2);
  317. r_ret = Math::inverse_lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
  318. } break;
  319. case MATH_RANGE_LERP: {
  320. VALIDATE_ARG_COUNT(5);
  321. VALIDATE_ARG_NUM(0);
  322. VALIDATE_ARG_NUM(1);
  323. VALIDATE_ARG_NUM(2);
  324. VALIDATE_ARG_NUM(3);
  325. VALIDATE_ARG_NUM(4);
  326. r_ret = Math::range_lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2], (double)*p_args[3], (double)*p_args[4]);
  327. } break;
  328. case MATH_DECTIME: {
  329. VALIDATE_ARG_COUNT(3);
  330. VALIDATE_ARG_NUM(0);
  331. VALIDATE_ARG_NUM(1);
  332. VALIDATE_ARG_NUM(2);
  333. r_ret = Math::dectime((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
  334. } break;
  335. case MATH_RANDOMIZE: {
  336. Math::randomize();
  337. r_ret = Variant();
  338. } break;
  339. case MATH_RAND: {
  340. r_ret = Math::rand();
  341. } break;
  342. case MATH_RANDF: {
  343. r_ret = Math::randf();
  344. } break;
  345. case MATH_RANDOM: {
  346. VALIDATE_ARG_COUNT(2);
  347. VALIDATE_ARG_NUM(0);
  348. VALIDATE_ARG_NUM(1);
  349. r_ret = Math::random((double)*p_args[0], (double)*p_args[1]);
  350. } break;
  351. case MATH_SEED: {
  352. VALIDATE_ARG_COUNT(1);
  353. VALIDATE_ARG_NUM(0);
  354. uint64_t seed = *p_args[0];
  355. Math::seed(seed);
  356. r_ret = Variant();
  357. } break;
  358. case MATH_RANDSEED: {
  359. VALIDATE_ARG_COUNT(1);
  360. VALIDATE_ARG_NUM(0);
  361. uint64_t seed = *p_args[0];
  362. int ret = Math::rand_from_seed(&seed);
  363. Array reta;
  364. reta.push_back(ret);
  365. reta.push_back(seed);
  366. r_ret = reta;
  367. } break;
  368. case MATH_DEG2RAD: {
  369. VALIDATE_ARG_COUNT(1);
  370. VALIDATE_ARG_NUM(0);
  371. r_ret = Math::deg2rad((double)*p_args[0]);
  372. } break;
  373. case MATH_RAD2DEG: {
  374. VALIDATE_ARG_COUNT(1);
  375. VALIDATE_ARG_NUM(0);
  376. r_ret = Math::rad2deg((double)*p_args[0]);
  377. } break;
  378. case MATH_LINEAR2DB: {
  379. VALIDATE_ARG_COUNT(1);
  380. VALIDATE_ARG_NUM(0);
  381. r_ret = Math::linear2db((double)*p_args[0]);
  382. } break;
  383. case MATH_DB2LINEAR: {
  384. VALIDATE_ARG_COUNT(1);
  385. VALIDATE_ARG_NUM(0);
  386. r_ret = Math::db2linear((double)*p_args[0]);
  387. } break;
  388. case LOGIC_MAX: {
  389. VALIDATE_ARG_COUNT(2);
  390. if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
  391. int64_t a = *p_args[0];
  392. int64_t b = *p_args[1];
  393. r_ret = MAX(a, b);
  394. } else {
  395. VALIDATE_ARG_NUM(0);
  396. VALIDATE_ARG_NUM(1);
  397. real_t a = *p_args[0];
  398. real_t b = *p_args[1];
  399. r_ret = MAX(a, b);
  400. }
  401. } break;
  402. case LOGIC_MIN: {
  403. VALIDATE_ARG_COUNT(2);
  404. if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
  405. int64_t a = *p_args[0];
  406. int64_t b = *p_args[1];
  407. r_ret = MIN(a, b);
  408. } else {
  409. VALIDATE_ARG_NUM(0);
  410. VALIDATE_ARG_NUM(1);
  411. real_t a = *p_args[0];
  412. real_t b = *p_args[1];
  413. r_ret = MIN(a, b);
  414. }
  415. } break;
  416. case LOGIC_CLAMP: {
  417. VALIDATE_ARG_COUNT(3);
  418. if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT && p_args[2]->get_type() == Variant::INT) {
  419. int64_t a = *p_args[0];
  420. int64_t b = *p_args[1];
  421. int64_t c = *p_args[2];
  422. r_ret = CLAMP(a, b, c);
  423. } else {
  424. VALIDATE_ARG_NUM(0);
  425. VALIDATE_ARG_NUM(1);
  426. VALIDATE_ARG_NUM(2);
  427. real_t a = *p_args[0];
  428. real_t b = *p_args[1];
  429. real_t c = *p_args[2];
  430. r_ret = CLAMP(a, b, c);
  431. }
  432. } break;
  433. case LOGIC_NEAREST_PO2: {
  434. VALIDATE_ARG_COUNT(1);
  435. VALIDATE_ARG_NUM(0);
  436. int64_t num = *p_args[0];
  437. r_ret = next_power_of_2(num);
  438. } break;
  439. case OBJ_WEAKREF: {
  440. VALIDATE_ARG_COUNT(1);
  441. if (p_args[0]->get_type() != Variant::OBJECT) {
  442. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  443. r_error.argument = 0;
  444. r_error.expected = Variant::OBJECT;
  445. r_ret = Variant();
  446. return;
  447. }
  448. if (p_args[0]->is_ref()) {
  449. REF r = *p_args[0];
  450. if (!r.is_valid()) {
  451. r_ret = Variant();
  452. return;
  453. }
  454. Ref<WeakRef> wref = memnew(WeakRef);
  455. wref->set_ref(r);
  456. r_ret = wref;
  457. } else {
  458. Object *obj = *p_args[0];
  459. if (!obj) {
  460. r_ret = Variant();
  461. return;
  462. }
  463. Ref<WeakRef> wref = memnew(WeakRef);
  464. wref->set_obj(obj);
  465. r_ret = wref;
  466. }
  467. } break;
  468. case FUNC_FUNCREF: {
  469. VALIDATE_ARG_COUNT(2);
  470. if (p_args[0]->get_type() != Variant::OBJECT) {
  471. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  472. r_error.argument = 0;
  473. r_error.expected = Variant::OBJECT;
  474. r_ret = Variant();
  475. return;
  476. }
  477. if (p_args[1]->get_type() != Variant::STRING && p_args[1]->get_type() != Variant::NODE_PATH) {
  478. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  479. r_error.argument = 1;
  480. r_error.expected = Variant::STRING;
  481. r_ret = Variant();
  482. return;
  483. }
  484. Ref<FuncRef> fr = memnew(FuncRef);
  485. fr->set_instance(*p_args[0]);
  486. fr->set_function(*p_args[1]);
  487. r_ret = fr;
  488. } break;
  489. case TYPE_CONVERT: {
  490. VALIDATE_ARG_COUNT(2);
  491. VALIDATE_ARG_NUM(1);
  492. int type = *p_args[1];
  493. if (type < 0 || type >= Variant::VARIANT_MAX) {
  494. r_ret = RTR("Invalid type argument to convert(), use TYPE_* constants.");
  495. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  496. r_error.argument = 0;
  497. r_error.expected = Variant::INT;
  498. return;
  499. } else {
  500. r_ret = Variant::construct(Variant::Type(type), p_args, 1, r_error);
  501. }
  502. } break;
  503. case TYPE_OF: {
  504. VALIDATE_ARG_COUNT(1);
  505. r_ret = p_args[0]->get_type();
  506. } break;
  507. case TYPE_EXISTS: {
  508. VALIDATE_ARG_COUNT(1);
  509. r_ret = ClassDB::class_exists(*p_args[0]);
  510. } break;
  511. case TEXT_CHAR: {
  512. VALIDATE_ARG_COUNT(1);
  513. VALIDATE_ARG_NUM(0);
  514. CharType result[2] = { *p_args[0], 0 };
  515. r_ret = String(result);
  516. } break;
  517. case TEXT_STR: {
  518. String str;
  519. for (int i = 0; i < p_arg_count; i++) {
  520. String os = p_args[i]->operator String();
  521. if (i == 0)
  522. str = os;
  523. else
  524. str += os;
  525. }
  526. r_ret = str;
  527. } break;
  528. case TEXT_PRINT: {
  529. String str;
  530. for (int i = 0; i < p_arg_count; i++) {
  531. str += p_args[i]->operator String();
  532. }
  533. //str+="\n";
  534. print_line(str);
  535. r_ret = Variant();
  536. } break;
  537. case TEXT_PRINT_TABBED: {
  538. String str;
  539. for (int i = 0; i < p_arg_count; i++) {
  540. if (i)
  541. str += "\t";
  542. str += p_args[i]->operator String();
  543. }
  544. //str+="\n";
  545. print_line(str);
  546. r_ret = Variant();
  547. } break;
  548. case TEXT_PRINT_SPACED: {
  549. String str;
  550. for (int i = 0; i < p_arg_count; i++) {
  551. if (i)
  552. str += " ";
  553. str += p_args[i]->operator String();
  554. }
  555. //str+="\n";
  556. print_line(str);
  557. r_ret = Variant();
  558. } break;
  559. case TEXT_PRINTERR: {
  560. String str;
  561. for (int i = 0; i < p_arg_count; i++) {
  562. str += p_args[i]->operator String();
  563. }
  564. //str+="\n";
  565. OS::get_singleton()->printerr("%s\n", str.utf8().get_data());
  566. r_ret = Variant();
  567. } break;
  568. case TEXT_PRINTRAW: {
  569. String str;
  570. for (int i = 0; i < p_arg_count; i++) {
  571. str += p_args[i]->operator String();
  572. }
  573. //str+="\n";
  574. OS::get_singleton()->print("%s", str.utf8().get_data());
  575. r_ret = Variant();
  576. } break;
  577. case VAR_TO_STR: {
  578. VALIDATE_ARG_COUNT(1);
  579. String vars;
  580. VariantWriter::write_to_string(*p_args[0], vars);
  581. r_ret = vars;
  582. } break;
  583. case STR_TO_VAR: {
  584. VALIDATE_ARG_COUNT(1);
  585. if (p_args[0]->get_type() != Variant::STRING) {
  586. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  587. r_error.argument = 0;
  588. r_error.expected = Variant::STRING;
  589. r_ret = Variant();
  590. return;
  591. }
  592. VariantParser::StreamString ss;
  593. ss.s = *p_args[0];
  594. String errs;
  595. int line;
  596. Error err = VariantParser::parse(&ss, r_ret, errs, line);
  597. if (err != OK) {
  598. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  599. r_error.argument = 0;
  600. r_error.expected = Variant::STRING;
  601. r_ret = "Parse error at line " + itos(line) + ": " + errs;
  602. return;
  603. }
  604. } break;
  605. case VAR_TO_BYTES: {
  606. VALIDATE_ARG_COUNT(1);
  607. PoolByteArray barr;
  608. int len;
  609. Error err = encode_variant(*p_args[0], NULL, len);
  610. if (err) {
  611. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  612. r_error.argument = 0;
  613. r_error.expected = Variant::NIL;
  614. r_ret = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
  615. return;
  616. }
  617. barr.resize(len);
  618. {
  619. PoolByteArray::Write w = barr.write();
  620. encode_variant(*p_args[0], w.ptr(), len);
  621. }
  622. r_ret = barr;
  623. } break;
  624. case BYTES_TO_VAR: {
  625. VALIDATE_ARG_COUNT(1);
  626. if (p_args[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
  627. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  628. r_error.argument = 0;
  629. r_error.expected = Variant::POOL_BYTE_ARRAY;
  630. r_ret = Variant();
  631. return;
  632. }
  633. PoolByteArray varr = *p_args[0];
  634. Variant ret;
  635. {
  636. PoolByteArray::Read r = varr.read();
  637. Error err = decode_variant(ret, r.ptr(), varr.size(), NULL);
  638. if (err != OK) {
  639. r_ret = RTR("Not enough bytes for decoding bytes, or invalid format.");
  640. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  641. r_error.argument = 0;
  642. r_error.expected = Variant::POOL_BYTE_ARRAY;
  643. return;
  644. }
  645. }
  646. r_ret = ret;
  647. } break;
  648. case GEN_RANGE: {
  649. switch (p_arg_count) {
  650. case 0: {
  651. r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
  652. r_error.argument = 1;
  653. r_ret = Variant();
  654. } break;
  655. case 1: {
  656. VALIDATE_ARG_NUM(0);
  657. int count = *p_args[0];
  658. Array arr;
  659. if (count <= 0) {
  660. r_ret = arr;
  661. return;
  662. }
  663. Error err = arr.resize(count);
  664. if (err != OK) {
  665. r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
  666. r_ret = Variant();
  667. return;
  668. }
  669. for (int i = 0; i < count; i++) {
  670. arr[i] = i;
  671. }
  672. r_ret = arr;
  673. } break;
  674. case 2: {
  675. VALIDATE_ARG_NUM(0);
  676. VALIDATE_ARG_NUM(1);
  677. int from = *p_args[0];
  678. int to = *p_args[1];
  679. Array arr;
  680. if (from >= to) {
  681. r_ret = arr;
  682. return;
  683. }
  684. Error err = arr.resize(to - from);
  685. if (err != OK) {
  686. r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
  687. r_ret = Variant();
  688. return;
  689. }
  690. for (int i = from; i < to; i++)
  691. arr[i - from] = i;
  692. r_ret = arr;
  693. } break;
  694. case 3: {
  695. VALIDATE_ARG_NUM(0);
  696. VALIDATE_ARG_NUM(1);
  697. VALIDATE_ARG_NUM(2);
  698. int from = *p_args[0];
  699. int to = *p_args[1];
  700. int incr = *p_args[2];
  701. if (incr == 0) {
  702. r_ret = RTR("step argument is zero!");
  703. r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
  704. return;
  705. }
  706. Array arr;
  707. if (from >= to && incr > 0) {
  708. r_ret = arr;
  709. return;
  710. }
  711. if (from <= to && incr < 0) {
  712. r_ret = arr;
  713. return;
  714. }
  715. //calculate how many
  716. int count = 0;
  717. if (incr > 0) {
  718. count = ((to - from - 1) / incr) + 1;
  719. } else {
  720. count = ((from - to - 1) / -incr) + 1;
  721. }
  722. Error err = arr.resize(count);
  723. if (err != OK) {
  724. r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
  725. r_ret = Variant();
  726. return;
  727. }
  728. if (incr > 0) {
  729. int idx = 0;
  730. for (int i = from; i < to; i += incr) {
  731. arr[idx++] = i;
  732. }
  733. } else {
  734. int idx = 0;
  735. for (int i = from; i > to; i += incr) {
  736. arr[idx++] = i;
  737. }
  738. }
  739. r_ret = arr;
  740. } break;
  741. default: {
  742. r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
  743. r_error.argument = 3;
  744. r_ret = Variant();
  745. } break;
  746. }
  747. } break;
  748. case RESOURCE_LOAD: {
  749. VALIDATE_ARG_COUNT(1);
  750. if (p_args[0]->get_type() != Variant::STRING) {
  751. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  752. r_error.argument = 0;
  753. r_error.expected = Variant::STRING;
  754. r_ret = Variant();
  755. } else {
  756. r_ret = ResourceLoader::load(*p_args[0]);
  757. }
  758. } break;
  759. case INST2DICT: {
  760. VALIDATE_ARG_COUNT(1);
  761. if (p_args[0]->get_type() == Variant::NIL) {
  762. r_ret = Variant();
  763. } else if (p_args[0]->get_type() != Variant::OBJECT) {
  764. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  765. r_error.argument = 0;
  766. r_ret = Variant();
  767. } else {
  768. Object *obj = *p_args[0];
  769. if (!obj) {
  770. r_ret = Variant();
  771. } else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != GDScriptLanguage::get_singleton()) {
  772. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  773. r_error.argument = 0;
  774. r_error.expected = Variant::DICTIONARY;
  775. r_ret = RTR("Not a script with an instance");
  776. return;
  777. } else {
  778. GDInstance *ins = static_cast<GDInstance *>(obj->get_script_instance());
  779. Ref<GDScript> base = ins->get_script();
  780. if (base.is_null()) {
  781. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  782. r_error.argument = 0;
  783. r_error.expected = Variant::DICTIONARY;
  784. r_ret = RTR("Not based on a script");
  785. return;
  786. }
  787. GDScript *p = base.ptr();
  788. Vector<StringName> sname;
  789. while (p->_owner) {
  790. sname.push_back(p->name);
  791. p = p->_owner;
  792. }
  793. sname.invert();
  794. if (!p->path.is_resource_file()) {
  795. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  796. r_error.argument = 0;
  797. r_error.expected = Variant::DICTIONARY;
  798. r_ret = Variant();
  799. r_ret = RTR("Not based on a resource file");
  800. return;
  801. }
  802. NodePath cp(sname, Vector<StringName>(), false);
  803. Dictionary d;
  804. d["@subpath"] = cp;
  805. d["@path"] = p->path;
  806. p = base.ptr();
  807. while (p) {
  808. for (Set<StringName>::Element *E = p->members.front(); E; E = E->next()) {
  809. Variant value;
  810. if (ins->get(E->get(), value)) {
  811. String k = E->get();
  812. if (!d.has(k)) {
  813. d[k] = value;
  814. }
  815. }
  816. }
  817. p = p->_base;
  818. }
  819. r_ret = d;
  820. }
  821. }
  822. } break;
  823. case DICT2INST: {
  824. VALIDATE_ARG_COUNT(1);
  825. if (p_args[0]->get_type() != Variant::DICTIONARY) {
  826. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  827. r_error.argument = 0;
  828. r_error.expected = Variant::DICTIONARY;
  829. r_ret = Variant();
  830. return;
  831. }
  832. Dictionary d = *p_args[0];
  833. if (!d.has("@path")) {
  834. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  835. r_error.argument = 0;
  836. r_error.expected = Variant::OBJECT;
  837. r_ret = RTR("Invalid instance dictionary format (missing @path)");
  838. return;
  839. }
  840. Ref<Script> scr = ResourceLoader::load(d["@path"]);
  841. if (!scr.is_valid()) {
  842. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  843. r_error.argument = 0;
  844. r_error.expected = Variant::OBJECT;
  845. r_ret = RTR("Invalid instance dictionary format (can't load script at @path)");
  846. return;
  847. }
  848. Ref<GDScript> gdscr = scr;
  849. if (!gdscr.is_valid()) {
  850. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  851. r_error.argument = 0;
  852. r_error.expected = Variant::OBJECT;
  853. r_ret = Variant();
  854. r_ret = RTR("Invalid instance dictionary format (invalid script at @path)");
  855. return;
  856. }
  857. NodePath sub;
  858. if (d.has("@subpath")) {
  859. sub = d["@subpath"];
  860. }
  861. for (int i = 0; i < sub.get_name_count(); i++) {
  862. gdscr = gdscr->subclasses[sub.get_name(i)];
  863. if (!gdscr.is_valid()) {
  864. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  865. r_error.argument = 0;
  866. r_error.expected = Variant::OBJECT;
  867. r_ret = Variant();
  868. r_ret = RTR("Invalid instance dictionary (invalid subclasses)");
  869. return;
  870. }
  871. }
  872. r_ret = gdscr->_new(NULL, 0, r_error);
  873. GDInstance *ins = static_cast<GDInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
  874. Ref<GDScript> gd_ref = ins->get_script();
  875. for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
  876. if (d.has(E->key())) {
  877. ins->members[E->get().index] = d[E->key()];
  878. }
  879. }
  880. } break;
  881. case VALIDATE_JSON: {
  882. VALIDATE_ARG_COUNT(1);
  883. if (p_args[0]->get_type() != Variant::STRING) {
  884. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  885. r_error.argument = 0;
  886. r_error.expected = Variant::STRING;
  887. r_ret = Variant();
  888. return;
  889. }
  890. String errs;
  891. int errl;
  892. Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
  893. if (err != OK) {
  894. r_ret = itos(errl) + ":" + errs;
  895. } else {
  896. r_ret = "";
  897. }
  898. } break;
  899. case PARSE_JSON: {
  900. VALIDATE_ARG_COUNT(1);
  901. if (p_args[0]->get_type() != Variant::STRING) {
  902. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  903. r_error.argument = 0;
  904. r_error.expected = Variant::STRING;
  905. r_ret = Variant();
  906. return;
  907. }
  908. String errs;
  909. int errl;
  910. Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
  911. if (err != OK) {
  912. r_ret = Variant();
  913. }
  914. } break;
  915. case TO_JSON: {
  916. VALIDATE_ARG_COUNT(1);
  917. r_ret = JSON::print(*p_args[0]);
  918. } break;
  919. case HASH: {
  920. VALIDATE_ARG_COUNT(1);
  921. r_ret = p_args[0]->hash();
  922. } break;
  923. case COLOR8: {
  924. if (p_arg_count < 3) {
  925. r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
  926. r_error.argument = 3;
  927. r_ret = Variant();
  928. return;
  929. }
  930. if (p_arg_count > 4) {
  931. r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
  932. r_error.argument = 4;
  933. r_ret = Variant();
  934. return;
  935. }
  936. VALIDATE_ARG_NUM(0);
  937. VALIDATE_ARG_NUM(1);
  938. VALIDATE_ARG_NUM(2);
  939. Color color((float)*p_args[0] / 255.0f, (float)*p_args[1] / 255.0f, (float)*p_args[2] / 255.0f);
  940. if (p_arg_count == 4) {
  941. VALIDATE_ARG_NUM(3);
  942. color.a = (float)*p_args[3] / 255.0f;
  943. }
  944. r_ret = color;
  945. } break;
  946. case COLORN: {
  947. if (p_arg_count < 1) {
  948. r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
  949. r_error.argument = 1;
  950. r_ret = Variant();
  951. return;
  952. }
  953. if (p_arg_count > 2) {
  954. r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
  955. r_error.argument = 2;
  956. r_ret = Variant();
  957. return;
  958. }
  959. if (p_args[0]->get_type() != Variant::STRING) {
  960. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  961. r_error.argument = 0;
  962. r_ret = Variant();
  963. } else {
  964. Color color = Color::named(*p_args[0]);
  965. if (p_arg_count == 2) {
  966. VALIDATE_ARG_NUM(1);
  967. color.a = *p_args[1];
  968. }
  969. r_ret = color;
  970. }
  971. } break;
  972. case PRINT_STACK: {
  973. ScriptLanguage *script = GDScriptLanguage::get_singleton();
  974. for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
  975. print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
  976. };
  977. } break;
  978. case INSTANCE_FROM_ID: {
  979. VALIDATE_ARG_COUNT(1);
  980. if (p_args[0]->get_type() != Variant::INT && p_args[0]->get_type() != Variant::REAL) {
  981. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  982. r_error.argument = 0;
  983. r_error.expected = Variant::INT;
  984. r_ret = Variant();
  985. break;
  986. }
  987. uint32_t id = *p_args[0];
  988. r_ret = ObjectDB::get_instance(id);
  989. } break;
  990. case LEN: {
  991. VALIDATE_ARG_COUNT(1);
  992. switch (p_args[0]->get_type()) {
  993. case Variant::DICTIONARY: {
  994. Dictionary d = *p_args[0];
  995. r_ret = d.size();
  996. } break;
  997. case Variant::ARRAY: {
  998. Array d = *p_args[0];
  999. r_ret = d.size();
  1000. } break;
  1001. case Variant::POOL_BYTE_ARRAY: {
  1002. PoolVector<uint8_t> d = *p_args[0];
  1003. r_ret = d.size();
  1004. } break;
  1005. case Variant::POOL_INT_ARRAY: {
  1006. PoolVector<int> d = *p_args[0];
  1007. r_ret = d.size();
  1008. } break;
  1009. case Variant::POOL_REAL_ARRAY: {
  1010. PoolVector<real_t> d = *p_args[0];
  1011. r_ret = d.size();
  1012. } break;
  1013. case Variant::POOL_STRING_ARRAY: {
  1014. PoolVector<String> d = *p_args[0];
  1015. r_ret = d.size();
  1016. } break;
  1017. case Variant::POOL_VECTOR2_ARRAY: {
  1018. PoolVector<Vector2> d = *p_args[0];
  1019. r_ret = d.size();
  1020. } break;
  1021. case Variant::POOL_VECTOR3_ARRAY: {
  1022. PoolVector<Vector3> d = *p_args[0];
  1023. r_ret = d.size();
  1024. } break;
  1025. case Variant::POOL_COLOR_ARRAY: {
  1026. PoolVector<Color> d = *p_args[0];
  1027. r_ret = d.size();
  1028. } break;
  1029. default: {
  1030. r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  1031. r_error.argument = 0;
  1032. r_error.expected = Variant::OBJECT;
  1033. r_ret = Variant();
  1034. r_ret = RTR("Object can't provide a length.");
  1035. }
  1036. }
  1037. } break;
  1038. case FUNC_MAX: {
  1039. ERR_FAIL();
  1040. } break;
  1041. }
  1042. }
  1043. bool GDFunctions::is_deterministic(Function p_func) {
  1044. //man i couldn't have chosen a worse function name,
  1045. //way too controversial..
  1046. switch (p_func) {
  1047. case MATH_SIN:
  1048. case MATH_COS:
  1049. case MATH_TAN:
  1050. case MATH_SINH:
  1051. case MATH_COSH:
  1052. case MATH_TANH:
  1053. case MATH_ASIN:
  1054. case MATH_ACOS:
  1055. case MATH_ATAN:
  1056. case MATH_ATAN2:
  1057. case MATH_SQRT:
  1058. case MATH_FMOD:
  1059. case MATH_FPOSMOD:
  1060. case MATH_FLOOR:
  1061. case MATH_CEIL:
  1062. case MATH_ROUND:
  1063. case MATH_ABS:
  1064. case MATH_SIGN:
  1065. case MATH_POW:
  1066. case MATH_LOG:
  1067. case MATH_EXP:
  1068. case MATH_ISNAN:
  1069. case MATH_ISINF:
  1070. case MATH_EASE:
  1071. case MATH_DECIMALS:
  1072. case MATH_STEPIFY:
  1073. case MATH_LERP:
  1074. case MATH_INVERSE_LERP:
  1075. case MATH_RANGE_LERP:
  1076. case MATH_DECTIME:
  1077. case MATH_DEG2RAD:
  1078. case MATH_RAD2DEG:
  1079. case MATH_LINEAR2DB:
  1080. case MATH_DB2LINEAR:
  1081. case LOGIC_MAX:
  1082. case LOGIC_MIN:
  1083. case LOGIC_CLAMP:
  1084. case LOGIC_NEAREST_PO2:
  1085. case TYPE_CONVERT:
  1086. case TYPE_OF:
  1087. case TYPE_EXISTS:
  1088. case TEXT_CHAR:
  1089. case TEXT_STR:
  1090. case COLOR8:
  1091. case LEN:
  1092. // enable for debug only, otherwise not desirable - case GEN_RANGE:
  1093. return true;
  1094. default:
  1095. return false;
  1096. }
  1097. return false;
  1098. }
  1099. MethodInfo GDFunctions::get_info(Function p_func) {
  1100. #ifdef TOOLS_ENABLED
  1101. //using a switch, so the compiler generates a jumptable
  1102. switch (p_func) {
  1103. case MATH_SIN: {
  1104. MethodInfo mi("sin", PropertyInfo(Variant::REAL, "s"));
  1105. mi.return_val.type = Variant::REAL;
  1106. return mi;
  1107. } break;
  1108. case MATH_COS: {
  1109. MethodInfo mi("cos", PropertyInfo(Variant::REAL, "s"));
  1110. mi.return_val.type = Variant::REAL;
  1111. return mi;
  1112. } break;
  1113. case MATH_TAN: {
  1114. MethodInfo mi("tan", PropertyInfo(Variant::REAL, "s"));
  1115. mi.return_val.type = Variant::REAL;
  1116. return mi;
  1117. } break;
  1118. case MATH_SINH: {
  1119. MethodInfo mi("sinh", PropertyInfo(Variant::REAL, "s"));
  1120. mi.return_val.type = Variant::REAL;
  1121. return mi;
  1122. } break;
  1123. case MATH_COSH: {
  1124. MethodInfo mi("cosh", PropertyInfo(Variant::REAL, "s"));
  1125. mi.return_val.type = Variant::REAL;
  1126. return mi;
  1127. } break;
  1128. case MATH_TANH: {
  1129. MethodInfo mi("tanh", PropertyInfo(Variant::REAL, "s"));
  1130. mi.return_val.type = Variant::REAL;
  1131. return mi;
  1132. } break;
  1133. case MATH_ASIN: {
  1134. MethodInfo mi("asin", PropertyInfo(Variant::REAL, "s"));
  1135. mi.return_val.type = Variant::REAL;
  1136. return mi;
  1137. } break;
  1138. case MATH_ACOS: {
  1139. MethodInfo mi("acos", PropertyInfo(Variant::REAL, "s"));
  1140. mi.return_val.type = Variant::REAL;
  1141. return mi;
  1142. } break;
  1143. case MATH_ATAN: {
  1144. MethodInfo mi("atan", PropertyInfo(Variant::REAL, "s"));
  1145. mi.return_val.type = Variant::REAL;
  1146. return mi;
  1147. } break;
  1148. case MATH_ATAN2: {
  1149. MethodInfo mi("atan2", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
  1150. mi.return_val.type = Variant::REAL;
  1151. return mi;
  1152. } break;
  1153. case MATH_SQRT: {
  1154. MethodInfo mi("sqrt", PropertyInfo(Variant::REAL, "s"));
  1155. mi.return_val.type = Variant::REAL;
  1156. return mi;
  1157. } break;
  1158. case MATH_FMOD: {
  1159. MethodInfo mi("fmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
  1160. mi.return_val.type = Variant::REAL;
  1161. return mi;
  1162. } break;
  1163. case MATH_FPOSMOD: {
  1164. MethodInfo mi("fposmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
  1165. mi.return_val.type = Variant::REAL;
  1166. return mi;
  1167. } break;
  1168. case MATH_FLOOR: {
  1169. MethodInfo mi("floor", PropertyInfo(Variant::REAL, "s"));
  1170. mi.return_val.type = Variant::REAL;
  1171. return mi;
  1172. } break;
  1173. case MATH_CEIL: {
  1174. MethodInfo mi("ceil", PropertyInfo(Variant::REAL, "s"));
  1175. mi.return_val.type = Variant::REAL;
  1176. return mi;
  1177. } break;
  1178. case MATH_ROUND: {
  1179. MethodInfo mi("round", PropertyInfo(Variant::REAL, "s"));
  1180. mi.return_val.type = Variant::REAL;
  1181. return mi;
  1182. } break;
  1183. case MATH_ABS: {
  1184. MethodInfo mi("abs", PropertyInfo(Variant::REAL, "s"));
  1185. mi.return_val.type = Variant::REAL;
  1186. return mi;
  1187. } break;
  1188. case MATH_SIGN: {
  1189. MethodInfo mi("sign", PropertyInfo(Variant::REAL, "s"));
  1190. mi.return_val.type = Variant::REAL;
  1191. return mi;
  1192. } break;
  1193. case MATH_POW: {
  1194. MethodInfo mi("pow", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
  1195. mi.return_val.type = Variant::REAL;
  1196. return mi;
  1197. } break;
  1198. case MATH_LOG: {
  1199. MethodInfo mi("log", PropertyInfo(Variant::REAL, "s"));
  1200. mi.return_val.type = Variant::REAL;
  1201. return mi;
  1202. } break;
  1203. case MATH_EXP: {
  1204. MethodInfo mi("exp", PropertyInfo(Variant::REAL, "s"));
  1205. mi.return_val.type = Variant::REAL;
  1206. return mi;
  1207. } break;
  1208. case MATH_ISNAN: {
  1209. MethodInfo mi("is_nan", PropertyInfo(Variant::REAL, "s"));
  1210. mi.return_val.type = Variant::REAL;
  1211. return mi;
  1212. } break;
  1213. case MATH_ISINF: {
  1214. MethodInfo mi("is_inf", PropertyInfo(Variant::REAL, "s"));
  1215. mi.return_val.type = Variant::REAL;
  1216. return mi;
  1217. } break;
  1218. case MATH_EASE: {
  1219. MethodInfo mi("ease", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "curve"));
  1220. mi.return_val.type = Variant::REAL;
  1221. return mi;
  1222. } break;
  1223. case MATH_DECIMALS: {
  1224. MethodInfo mi("decimals", PropertyInfo(Variant::REAL, "step"));
  1225. mi.return_val.type = Variant::REAL;
  1226. return mi;
  1227. } break;
  1228. case MATH_STEPIFY: {
  1229. MethodInfo mi("stepify", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "step"));
  1230. mi.return_val.type = Variant::REAL;
  1231. return mi;
  1232. } break;
  1233. case MATH_LERP: {
  1234. MethodInfo mi("lerp", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
  1235. mi.return_val.type = Variant::REAL;
  1236. return mi;
  1237. } break;
  1238. case MATH_INVERSE_LERP: {
  1239. MethodInfo mi("inverse_lerp", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "value"));
  1240. mi.return_val.type = Variant::REAL;
  1241. return mi;
  1242. } break;
  1243. case MATH_RANGE_LERP: {
  1244. MethodInfo mi("range_lerp", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "istart"), PropertyInfo(Variant::REAL, "istop"), PropertyInfo(Variant::REAL, "ostart"), PropertyInfo(Variant::REAL, "ostop"));
  1245. mi.return_val.type = Variant::REAL;
  1246. return mi;
  1247. } break;
  1248. case MATH_DECTIME: {
  1249. MethodInfo mi("dectime", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "amount"), PropertyInfo(Variant::REAL, "step"));
  1250. mi.return_val.type = Variant::REAL;
  1251. return mi;
  1252. } break;
  1253. case MATH_RANDOMIZE: {
  1254. MethodInfo mi("randomize");
  1255. mi.return_val.type = Variant::NIL;
  1256. return mi;
  1257. } break;
  1258. case MATH_RAND: {
  1259. MethodInfo mi("randi");
  1260. mi.return_val.type = Variant::INT;
  1261. return mi;
  1262. } break;
  1263. case MATH_RANDF: {
  1264. MethodInfo mi("randf");
  1265. mi.return_val.type = Variant::REAL;
  1266. return mi;
  1267. } break;
  1268. case MATH_RANDOM: {
  1269. MethodInfo mi("rand_range", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"));
  1270. mi.return_val.type = Variant::REAL;
  1271. return mi;
  1272. } break;
  1273. case MATH_SEED: {
  1274. MethodInfo mi("seed", PropertyInfo(Variant::INT, "seed"));
  1275. mi.return_val.type = Variant::NIL;
  1276. return mi;
  1277. } break;
  1278. case MATH_RANDSEED: {
  1279. MethodInfo mi("rand_seed", PropertyInfo(Variant::INT, "seed"));
  1280. mi.return_val.type = Variant::ARRAY;
  1281. return mi;
  1282. } break;
  1283. case MATH_DEG2RAD: {
  1284. MethodInfo mi("deg2rad", PropertyInfo(Variant::REAL, "deg"));
  1285. mi.return_val.type = Variant::REAL;
  1286. return mi;
  1287. } break;
  1288. case MATH_RAD2DEG: {
  1289. MethodInfo mi("rad2deg", PropertyInfo(Variant::REAL, "rad"));
  1290. mi.return_val.type = Variant::REAL;
  1291. return mi;
  1292. } break;
  1293. case MATH_LINEAR2DB: {
  1294. MethodInfo mi("linear2db", PropertyInfo(Variant::REAL, "nrg"));
  1295. mi.return_val.type = Variant::REAL;
  1296. return mi;
  1297. } break;
  1298. case MATH_DB2LINEAR: {
  1299. MethodInfo mi("db2linear", PropertyInfo(Variant::REAL, "db"));
  1300. mi.return_val.type = Variant::REAL;
  1301. return mi;
  1302. } break;
  1303. case LOGIC_MAX: {
  1304. MethodInfo mi("max", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
  1305. mi.return_val.type = Variant::REAL;
  1306. return mi;
  1307. } break;
  1308. case LOGIC_MIN: {
  1309. MethodInfo mi("min", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
  1310. mi.return_val.type = Variant::REAL;
  1311. return mi;
  1312. } break;
  1313. case LOGIC_CLAMP: {
  1314. MethodInfo mi("clamp", PropertyInfo(Variant::REAL, "val"), PropertyInfo(Variant::REAL, "min"), PropertyInfo(Variant::REAL, "max"));
  1315. mi.return_val.type = Variant::REAL;
  1316. return mi;
  1317. } break;
  1318. case LOGIC_NEAREST_PO2: {
  1319. MethodInfo mi("nearest_po2", PropertyInfo(Variant::INT, "val"));
  1320. mi.return_val.type = Variant::INT;
  1321. return mi;
  1322. } break;
  1323. case OBJ_WEAKREF: {
  1324. MethodInfo mi("weakref", PropertyInfo(Variant::OBJECT, "obj"));
  1325. mi.return_val.type = Variant::OBJECT;
  1326. mi.return_val.name = "WeakRef";
  1327. return mi;
  1328. } break;
  1329. case FUNC_FUNCREF: {
  1330. MethodInfo mi("funcref", PropertyInfo(Variant::OBJECT, "instance"), PropertyInfo(Variant::STRING, "funcname"));
  1331. mi.return_val.type = Variant::OBJECT;
  1332. mi.return_val.name = "FuncRef";
  1333. return mi;
  1334. } break;
  1335. case TYPE_CONVERT: {
  1336. MethodInfo mi("convert", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::INT, "type"));
  1337. mi.return_val.type = Variant::OBJECT;
  1338. return mi;
  1339. } break;
  1340. case TYPE_OF: {
  1341. MethodInfo mi("typeof", PropertyInfo(Variant::NIL, "what"));
  1342. mi.return_val.type = Variant::INT;
  1343. return mi;
  1344. } break;
  1345. case TYPE_EXISTS: {
  1346. MethodInfo mi("type_exists", PropertyInfo(Variant::STRING, "type"));
  1347. mi.return_val.type = Variant::BOOL;
  1348. return mi;
  1349. } break;
  1350. case TEXT_CHAR: {
  1351. MethodInfo mi("char", PropertyInfo(Variant::INT, "ascii"));
  1352. mi.return_val.type = Variant::STRING;
  1353. return mi;
  1354. } break;
  1355. case TEXT_STR: {
  1356. MethodInfo mi("str");
  1357. mi.return_val.type = Variant::STRING;
  1358. mi.flags |= METHOD_FLAG_VARARG;
  1359. return mi;
  1360. } break;
  1361. case TEXT_PRINT: {
  1362. MethodInfo mi("print");
  1363. mi.return_val.type = Variant::NIL;
  1364. mi.flags |= METHOD_FLAG_VARARG;
  1365. return mi;
  1366. } break;
  1367. case TEXT_PRINT_TABBED: {
  1368. MethodInfo mi("printt");
  1369. mi.return_val.type = Variant::NIL;
  1370. mi.flags |= METHOD_FLAG_VARARG;
  1371. return mi;
  1372. } break;
  1373. case TEXT_PRINT_SPACED: {
  1374. MethodInfo mi("prints");
  1375. mi.return_val.type = Variant::NIL;
  1376. mi.flags |= METHOD_FLAG_VARARG;
  1377. return mi;
  1378. } break;
  1379. case TEXT_PRINTERR: {
  1380. MethodInfo mi("printerr");
  1381. mi.return_val.type = Variant::NIL;
  1382. mi.flags |= METHOD_FLAG_VARARG;
  1383. return mi;
  1384. } break;
  1385. case TEXT_PRINTRAW: {
  1386. MethodInfo mi("printraw");
  1387. mi.return_val.type = Variant::NIL;
  1388. mi.flags |= METHOD_FLAG_VARARG;
  1389. return mi;
  1390. } break;
  1391. case VAR_TO_STR: {
  1392. MethodInfo mi("var2str", PropertyInfo(Variant::NIL, "var"));
  1393. mi.return_val.type = Variant::STRING;
  1394. return mi;
  1395. } break;
  1396. case STR_TO_VAR: {
  1397. MethodInfo mi(Variant::NIL, "str2var", PropertyInfo(Variant::STRING, "string"));
  1398. mi.return_val.type = Variant::NIL;
  1399. mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  1400. return mi;
  1401. } break;
  1402. case VAR_TO_BYTES: {
  1403. MethodInfo mi("var2bytes", PropertyInfo(Variant::NIL, "var"));
  1404. mi.return_val.type = Variant::POOL_BYTE_ARRAY;
  1405. return mi;
  1406. } break;
  1407. case BYTES_TO_VAR: {
  1408. MethodInfo mi(Variant::NIL, "bytes2var", PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes"));
  1409. mi.return_val.type = Variant::NIL;
  1410. mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  1411. return mi;
  1412. } break;
  1413. case GEN_RANGE: {
  1414. MethodInfo mi("range");
  1415. mi.return_val.type = Variant::ARRAY;
  1416. mi.flags |= METHOD_FLAG_VARARG;
  1417. return mi;
  1418. } break;
  1419. case RESOURCE_LOAD: {
  1420. MethodInfo mi("load", PropertyInfo(Variant::STRING, "path"));
  1421. mi.return_val.type = Variant::OBJECT;
  1422. mi.return_val.name = "Resource";
  1423. return mi;
  1424. } break;
  1425. case INST2DICT: {
  1426. MethodInfo mi("inst2dict", PropertyInfo(Variant::OBJECT, "inst"));
  1427. mi.return_val.type = Variant::DICTIONARY;
  1428. return mi;
  1429. } break;
  1430. case DICT2INST: {
  1431. MethodInfo mi("dict2inst", PropertyInfo(Variant::DICTIONARY, "dict"));
  1432. mi.return_val.type = Variant::OBJECT;
  1433. return mi;
  1434. } break;
  1435. case VALIDATE_JSON: {
  1436. MethodInfo mi("validate_json", PropertyInfo(Variant::STRING, "json"));
  1437. mi.return_val.type = Variant::STRING;
  1438. return mi;
  1439. } break;
  1440. case PARSE_JSON: {
  1441. MethodInfo mi(Variant::NIL, "parse_json", PropertyInfo(Variant::STRING, "json"));
  1442. mi.return_val.type = Variant::NIL;
  1443. mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  1444. return mi;
  1445. } break;
  1446. case TO_JSON: {
  1447. MethodInfo mi("to_json", PropertyInfo(Variant::NIL, "var"));
  1448. mi.return_val.type = Variant::STRING;
  1449. return mi;
  1450. } break;
  1451. case HASH: {
  1452. MethodInfo mi("hash", PropertyInfo(Variant::NIL, "var"));
  1453. mi.return_val.type = Variant::INT;
  1454. return mi;
  1455. } break;
  1456. case COLOR8: {
  1457. MethodInfo mi("Color8", PropertyInfo(Variant::INT, "r8"), PropertyInfo(Variant::INT, "g8"), PropertyInfo(Variant::INT, "b8"), PropertyInfo(Variant::INT, "a8"));
  1458. mi.return_val.type = Variant::COLOR;
  1459. return mi;
  1460. } break;
  1461. case COLORN: {
  1462. MethodInfo mi("ColorN", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::REAL, "alpha"));
  1463. mi.return_val.type = Variant::COLOR;
  1464. return mi;
  1465. } break;
  1466. case PRINT_STACK: {
  1467. MethodInfo mi("print_stack");
  1468. mi.return_val.type = Variant::NIL;
  1469. return mi;
  1470. } break;
  1471. case INSTANCE_FROM_ID: {
  1472. MethodInfo mi("instance_from_id", PropertyInfo(Variant::INT, "instance_id"));
  1473. mi.return_val.type = Variant::OBJECT;
  1474. return mi;
  1475. } break;
  1476. case LEN: {
  1477. MethodInfo mi("len", PropertyInfo(Variant::NIL, "var"));
  1478. mi.return_val.type = Variant::INT;
  1479. return mi;
  1480. } break;
  1481. case FUNC_MAX: {
  1482. ERR_FAIL_V(MethodInfo());
  1483. } break;
  1484. }
  1485. #endif
  1486. return MethodInfo();
  1487. }