script_language.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585
  1. /*************************************************************************/
  2. /* script_language.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2022 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 "script_language.h"
  31. #include "core/config/project_settings.h"
  32. #include "core/core_string_names.h"
  33. #include "core/debugger/engine_debugger.h"
  34. #include "core/debugger/script_debugger.h"
  35. #include <stdint.h>
  36. ScriptLanguage *ScriptServer::_languages[MAX_LANGUAGES];
  37. int ScriptServer::_language_count = 0;
  38. bool ScriptServer::scripting_enabled = true;
  39. bool ScriptServer::reload_scripts_on_save = false;
  40. bool ScriptServer::languages_finished = false;
  41. ScriptEditRequestFunction ScriptServer::edit_request_func = nullptr;
  42. void Script::_notification(int p_what) {
  43. switch (p_what) {
  44. case NOTIFICATION_POSTINITIALIZE: {
  45. if (EngineDebugger::is_active()) {
  46. EngineDebugger::get_script_debugger()->set_break_language(get_language());
  47. }
  48. } break;
  49. }
  50. }
  51. Variant Script::_get_property_default_value(const StringName &p_property) {
  52. Variant ret;
  53. get_property_default_value(p_property, ret);
  54. return ret;
  55. }
  56. Array Script::_get_script_property_list() {
  57. Array ret;
  58. List<PropertyInfo> list;
  59. get_script_property_list(&list);
  60. for (const PropertyInfo &E : list) {
  61. ret.append(E.operator Dictionary());
  62. }
  63. return ret;
  64. }
  65. Array Script::_get_script_method_list() {
  66. Array ret;
  67. List<MethodInfo> list;
  68. get_script_method_list(&list);
  69. for (const MethodInfo &E : list) {
  70. ret.append(E.operator Dictionary());
  71. }
  72. return ret;
  73. }
  74. Array Script::_get_script_signal_list() {
  75. Array ret;
  76. List<MethodInfo> list;
  77. get_script_signal_list(&list);
  78. for (const MethodInfo &E : list) {
  79. ret.append(E.operator Dictionary());
  80. }
  81. return ret;
  82. }
  83. Dictionary Script::_get_script_constant_map() {
  84. Dictionary ret;
  85. Map<StringName, Variant> map;
  86. get_constants(&map);
  87. for (const KeyValue<StringName, Variant> &E : map) {
  88. ret[E.key] = E.value;
  89. }
  90. return ret;
  91. }
  92. void Script::_bind_methods() {
  93. ClassDB::bind_method(D_METHOD("can_instantiate"), &Script::can_instantiate);
  94. //ClassDB::bind_method(D_METHOD("instance_create","base_object"),&Script::instance_create);
  95. ClassDB::bind_method(D_METHOD("instance_has", "base_object"), &Script::instance_has);
  96. ClassDB::bind_method(D_METHOD("has_source_code"), &Script::has_source_code);
  97. ClassDB::bind_method(D_METHOD("get_source_code"), &Script::get_source_code);
  98. ClassDB::bind_method(D_METHOD("set_source_code", "source"), &Script::set_source_code);
  99. ClassDB::bind_method(D_METHOD("reload", "keep_state"), &Script::reload, DEFVAL(false));
  100. ClassDB::bind_method(D_METHOD("get_base_script"), &Script::get_base_script);
  101. ClassDB::bind_method(D_METHOD("get_instance_base_type"), &Script::get_instance_base_type);
  102. ClassDB::bind_method(D_METHOD("has_script_signal", "signal_name"), &Script::has_script_signal);
  103. ClassDB::bind_method(D_METHOD("get_script_property_list"), &Script::_get_script_property_list);
  104. ClassDB::bind_method(D_METHOD("get_script_method_list"), &Script::_get_script_method_list);
  105. ClassDB::bind_method(D_METHOD("get_script_signal_list"), &Script::_get_script_signal_list);
  106. ClassDB::bind_method(D_METHOD("get_script_constant_map"), &Script::_get_script_constant_map);
  107. ClassDB::bind_method(D_METHOD("get_property_default_value", "property"), &Script::_get_property_default_value);
  108. ClassDB::bind_method(D_METHOD("is_tool"), &Script::is_tool);
  109. ADD_PROPERTY(PropertyInfo(Variant::STRING, "source_code", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NONE), "set_source_code", "get_source_code");
  110. }
  111. void ScriptServer::set_scripting_enabled(bool p_enabled) {
  112. scripting_enabled = p_enabled;
  113. }
  114. bool ScriptServer::is_scripting_enabled() {
  115. return scripting_enabled;
  116. }
  117. ScriptLanguage *ScriptServer::get_language(int p_idx) {
  118. ERR_FAIL_INDEX_V(p_idx, _language_count, nullptr);
  119. return _languages[p_idx];
  120. }
  121. void ScriptServer::register_language(ScriptLanguage *p_language) {
  122. ERR_FAIL_COND(_language_count >= MAX_LANGUAGES);
  123. _languages[_language_count++] = p_language;
  124. }
  125. void ScriptServer::unregister_language(const ScriptLanguage *p_language) {
  126. for (int i = 0; i < _language_count; i++) {
  127. if (_languages[i] == p_language) {
  128. _language_count--;
  129. if (i < _language_count) {
  130. SWAP(_languages[i], _languages[_language_count]);
  131. }
  132. return;
  133. }
  134. }
  135. }
  136. void ScriptServer::init_languages() {
  137. { //load global classes
  138. global_classes_clear();
  139. if (ProjectSettings::get_singleton()->has_setting("_global_script_classes")) {
  140. Array script_classes = ProjectSettings::get_singleton()->get("_global_script_classes");
  141. for (int i = 0; i < script_classes.size(); i++) {
  142. Dictionary c = script_classes[i];
  143. if (!c.has("class") || !c.has("language") || !c.has("path") || !c.has("base")) {
  144. continue;
  145. }
  146. add_global_class(c["class"], c["base"], c["language"], c["path"]);
  147. }
  148. }
  149. }
  150. for (int i = 0; i < _language_count; i++) {
  151. _languages[i]->init();
  152. }
  153. }
  154. void ScriptServer::finish_languages() {
  155. for (int i = 0; i < _language_count; i++) {
  156. _languages[i]->finish();
  157. }
  158. global_classes_clear();
  159. languages_finished = true;
  160. }
  161. void ScriptServer::set_reload_scripts_on_save(bool p_enable) {
  162. reload_scripts_on_save = p_enable;
  163. }
  164. bool ScriptServer::is_reload_scripts_on_save_enabled() {
  165. return reload_scripts_on_save;
  166. }
  167. void ScriptServer::thread_enter() {
  168. for (int i = 0; i < _language_count; i++) {
  169. _languages[i]->thread_enter();
  170. }
  171. }
  172. void ScriptServer::thread_exit() {
  173. for (int i = 0; i < _language_count; i++) {
  174. _languages[i]->thread_exit();
  175. }
  176. }
  177. HashMap<StringName, ScriptServer::GlobalScriptClass> ScriptServer::global_classes;
  178. void ScriptServer::global_classes_clear() {
  179. global_classes.clear();
  180. }
  181. void ScriptServer::add_global_class(const StringName &p_class, const StringName &p_base, const StringName &p_language, const String &p_path) {
  182. ERR_FAIL_COND_MSG(p_class == p_base || (global_classes.has(p_base) && get_global_class_native_base(p_base) == p_class), "Cyclic inheritance in script class.");
  183. GlobalScriptClass g;
  184. g.language = p_language;
  185. g.path = p_path;
  186. g.base = p_base;
  187. global_classes[p_class] = g;
  188. }
  189. void ScriptServer::remove_global_class(const StringName &p_class) {
  190. global_classes.erase(p_class);
  191. }
  192. bool ScriptServer::is_global_class(const StringName &p_class) {
  193. return global_classes.has(p_class);
  194. }
  195. StringName ScriptServer::get_global_class_language(const StringName &p_class) {
  196. ERR_FAIL_COND_V(!global_classes.has(p_class), StringName());
  197. return global_classes[p_class].language;
  198. }
  199. String ScriptServer::get_global_class_path(const String &p_class) {
  200. ERR_FAIL_COND_V(!global_classes.has(p_class), String());
  201. return global_classes[p_class].path;
  202. }
  203. StringName ScriptServer::get_global_class_base(const String &p_class) {
  204. ERR_FAIL_COND_V(!global_classes.has(p_class), String());
  205. return global_classes[p_class].base;
  206. }
  207. StringName ScriptServer::get_global_class_native_base(const String &p_class) {
  208. ERR_FAIL_COND_V(!global_classes.has(p_class), String());
  209. String base = global_classes[p_class].base;
  210. while (global_classes.has(base)) {
  211. base = global_classes[base].base;
  212. }
  213. return base;
  214. }
  215. void ScriptServer::get_global_class_list(List<StringName> *r_global_classes) {
  216. List<StringName> classes;
  217. for (const KeyValue<StringName, GlobalScriptClass> &E : global_classes) {
  218. classes.push_back(E.key);
  219. }
  220. classes.sort_custom<StringName::AlphCompare>();
  221. for (const StringName &E : classes) {
  222. r_global_classes->push_back(E);
  223. }
  224. }
  225. void ScriptServer::save_global_classes() {
  226. List<StringName> gc;
  227. get_global_class_list(&gc);
  228. Array gcarr;
  229. for (const StringName &E : gc) {
  230. Dictionary d;
  231. d["class"] = E;
  232. d["language"] = global_classes[E].language;
  233. d["path"] = global_classes[E].path;
  234. d["base"] = global_classes[E].base;
  235. gcarr.push_back(d);
  236. }
  237. Array old;
  238. if (ProjectSettings::get_singleton()->has_setting("_global_script_classes")) {
  239. old = ProjectSettings::get_singleton()->get("_global_script_classes");
  240. }
  241. if ((!old.is_empty() || gcarr.is_empty()) && gcarr.hash() == old.hash()) {
  242. return;
  243. }
  244. if (gcarr.is_empty()) {
  245. if (ProjectSettings::get_singleton()->has_setting("_global_script_classes")) {
  246. ProjectSettings::get_singleton()->clear("_global_script_classes");
  247. }
  248. } else {
  249. ProjectSettings::get_singleton()->set("_global_script_classes", gcarr);
  250. }
  251. ProjectSettings::get_singleton()->save();
  252. }
  253. ////////////////////
  254. void ScriptInstance::get_property_state(List<Pair<StringName, Variant>> &state) {
  255. List<PropertyInfo> pinfo;
  256. get_property_list(&pinfo);
  257. for (const PropertyInfo &E : pinfo) {
  258. if (E.usage & PROPERTY_USAGE_STORAGE) {
  259. Pair<StringName, Variant> p;
  260. p.first = E.name;
  261. if (get(p.first, p.second)) {
  262. state.push_back(p);
  263. }
  264. }
  265. }
  266. }
  267. void ScriptInstance::property_set_fallback(const StringName &, const Variant &, bool *r_valid) {
  268. if (r_valid) {
  269. *r_valid = false;
  270. }
  271. }
  272. Variant ScriptInstance::property_get_fallback(const StringName &, bool *r_valid) {
  273. if (r_valid) {
  274. *r_valid = false;
  275. }
  276. return Variant();
  277. }
  278. ScriptInstance::~ScriptInstance() {
  279. }
  280. ScriptCodeCompletionCache *ScriptCodeCompletionCache::singleton = nullptr;
  281. ScriptCodeCompletionCache::ScriptCodeCompletionCache() {
  282. singleton = this;
  283. }
  284. void ScriptLanguage::get_core_type_words(List<String> *p_core_type_words) const {
  285. p_core_type_words->push_back("String");
  286. p_core_type_words->push_back("Vector2");
  287. p_core_type_words->push_back("Vector2i");
  288. p_core_type_words->push_back("Rect2");
  289. p_core_type_words->push_back("Rect2i");
  290. p_core_type_words->push_back("Vector3");
  291. p_core_type_words->push_back("Vector3i");
  292. p_core_type_words->push_back("Transform2D");
  293. p_core_type_words->push_back("Plane");
  294. p_core_type_words->push_back("Quaternion");
  295. p_core_type_words->push_back("AABB");
  296. p_core_type_words->push_back("Basis");
  297. p_core_type_words->push_back("Transform3D");
  298. p_core_type_words->push_back("Color");
  299. p_core_type_words->push_back("StringName");
  300. p_core_type_words->push_back("NodePath");
  301. p_core_type_words->push_back("RID");
  302. p_core_type_words->push_back("Callable");
  303. p_core_type_words->push_back("Signal");
  304. p_core_type_words->push_back("Dictionary");
  305. p_core_type_words->push_back("Array");
  306. p_core_type_words->push_back("PackedByteArray");
  307. p_core_type_words->push_back("PackedInt32Array");
  308. p_core_type_words->push_back("PackedInt64Array");
  309. p_core_type_words->push_back("PackedFloat32Array");
  310. p_core_type_words->push_back("PackedFloat64Array");
  311. p_core_type_words->push_back("PackedStringArray");
  312. p_core_type_words->push_back("PackedVector2Array");
  313. p_core_type_words->push_back("PackedVector3Array");
  314. p_core_type_words->push_back("PackedColorArray");
  315. }
  316. void ScriptLanguage::frame() {
  317. }
  318. bool PlaceHolderScriptInstance::set(const StringName &p_name, const Variant &p_value) {
  319. if (script->is_placeholder_fallback_enabled()) {
  320. return false;
  321. }
  322. if (values.has(p_name)) {
  323. Variant defval;
  324. if (script->get_property_default_value(p_name, defval)) {
  325. if (defval == p_value) {
  326. values.erase(p_name);
  327. return true;
  328. }
  329. }
  330. values[p_name] = p_value;
  331. return true;
  332. } else {
  333. Variant defval;
  334. if (script->get_property_default_value(p_name, defval)) {
  335. if (defval != p_value) {
  336. values[p_name] = p_value;
  337. }
  338. return true;
  339. }
  340. }
  341. return false;
  342. }
  343. bool PlaceHolderScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
  344. if (values.has(p_name)) {
  345. r_ret = values[p_name];
  346. return true;
  347. }
  348. if (constants.has(p_name)) {
  349. r_ret = constants[p_name];
  350. return true;
  351. }
  352. if (!script->is_placeholder_fallback_enabled()) {
  353. Variant defval;
  354. if (script->get_property_default_value(p_name, defval)) {
  355. r_ret = defval;
  356. return true;
  357. }
  358. }
  359. return false;
  360. }
  361. void PlaceHolderScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
  362. if (script->is_placeholder_fallback_enabled()) {
  363. for (const PropertyInfo &E : properties) {
  364. p_properties->push_back(E);
  365. }
  366. } else {
  367. for (const PropertyInfo &E : properties) {
  368. PropertyInfo pinfo = E;
  369. if (!values.has(pinfo.name)) {
  370. pinfo.usage |= PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE;
  371. }
  372. p_properties->push_back(E);
  373. }
  374. }
  375. }
  376. Variant::Type PlaceHolderScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
  377. if (values.has(p_name)) {
  378. if (r_is_valid) {
  379. *r_is_valid = true;
  380. }
  381. return values[p_name].get_type();
  382. }
  383. if (constants.has(p_name)) {
  384. if (r_is_valid) {
  385. *r_is_valid = true;
  386. }
  387. return constants[p_name].get_type();
  388. }
  389. if (r_is_valid) {
  390. *r_is_valid = false;
  391. }
  392. return Variant::NIL;
  393. }
  394. void PlaceHolderScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
  395. if (script->is_placeholder_fallback_enabled()) {
  396. return;
  397. }
  398. if (script.is_valid()) {
  399. script->get_script_method_list(p_list);
  400. }
  401. }
  402. bool PlaceHolderScriptInstance::has_method(const StringName &p_method) const {
  403. if (script->is_placeholder_fallback_enabled()) {
  404. return false;
  405. }
  406. if (script.is_valid()) {
  407. return script->has_method(p_method);
  408. }
  409. return false;
  410. }
  411. void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, const Map<StringName, Variant> &p_values) {
  412. Set<StringName> new_values;
  413. for (const PropertyInfo &E : p_properties) {
  414. StringName n = E.name;
  415. new_values.insert(n);
  416. if (!values.has(n) || values[n].get_type() != E.type) {
  417. if (p_values.has(n)) {
  418. values[n] = p_values[n];
  419. }
  420. }
  421. }
  422. properties = p_properties;
  423. List<StringName> to_remove;
  424. for (Map<StringName, Variant>::Element *E = values.front(); E; E = E->next()) {
  425. if (!new_values.has(E->key())) {
  426. to_remove.push_back(E->key());
  427. }
  428. Variant defval;
  429. if (script->get_property_default_value(E->key(), defval)) {
  430. //remove because it's the same as the default value
  431. if (defval == E->get()) {
  432. to_remove.push_back(E->key());
  433. }
  434. }
  435. }
  436. while (to_remove.size()) {
  437. values.erase(to_remove.front()->get());
  438. to_remove.pop_front();
  439. }
  440. if (owner && owner->get_script_instance() == this) {
  441. owner->notify_property_list_changed();
  442. }
  443. //change notify
  444. constants.clear();
  445. script->get_constants(&constants);
  446. }
  447. void PlaceHolderScriptInstance::property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) {
  448. if (script->is_placeholder_fallback_enabled()) {
  449. Map<StringName, Variant>::Element *E = values.find(p_name);
  450. if (E) {
  451. E->value() = p_value;
  452. } else {
  453. values.insert(p_name, p_value);
  454. }
  455. bool found = false;
  456. for (const PropertyInfo &F : properties) {
  457. if (F.name == p_name) {
  458. found = true;
  459. break;
  460. }
  461. }
  462. if (!found) {
  463. properties.push_back(PropertyInfo(p_value.get_type(), p_name, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_SCRIPT_VARIABLE));
  464. }
  465. }
  466. if (r_valid) {
  467. *r_valid = false; // Cannot change the value in either case
  468. }
  469. }
  470. Variant PlaceHolderScriptInstance::property_get_fallback(const StringName &p_name, bool *r_valid) {
  471. if (script->is_placeholder_fallback_enabled()) {
  472. const Map<StringName, Variant>::Element *E = values.find(p_name);
  473. if (E) {
  474. if (r_valid) {
  475. *r_valid = true;
  476. }
  477. return E->value();
  478. }
  479. E = constants.find(p_name);
  480. if (E) {
  481. if (r_valid) {
  482. *r_valid = true;
  483. }
  484. return E->value();
  485. }
  486. }
  487. if (r_valid) {
  488. *r_valid = false;
  489. }
  490. return Variant();
  491. }
  492. PlaceHolderScriptInstance::PlaceHolderScriptInstance(ScriptLanguage *p_language, Ref<Script> p_script, Object *p_owner) :
  493. owner(p_owner),
  494. language(p_language),
  495. script(p_script) {
  496. }
  497. PlaceHolderScriptInstance::~PlaceHolderScriptInstance() {
  498. if (script.is_valid()) {
  499. script->_placeholder_erased(this);
  500. }
  501. }