library_godot_display.js 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741
  1. /*************************************************************************/
  2. /* library_godot_display.js */
  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. const GodotDisplayVK = {
  31. $GodotDisplayVK__deps: ['$GodotRuntime', '$GodotConfig', '$GodotEventListeners'],
  32. $GodotDisplayVK__postset: 'GodotOS.atexit(function(resolve, reject) { GodotDisplayVK.clear(); resolve(); });',
  33. $GodotDisplayVK: {
  34. textinput: null,
  35. textarea: null,
  36. available: function () {
  37. return GodotConfig.virtual_keyboard && 'ontouchstart' in window;
  38. },
  39. init: function (input_cb) {
  40. function create(what) {
  41. const elem = document.createElement(what);
  42. elem.style.display = 'none';
  43. elem.style.position = 'absolute';
  44. elem.style.zIndex = '-1';
  45. elem.style.background = 'transparent';
  46. elem.style.padding = '0px';
  47. elem.style.margin = '0px';
  48. elem.style.overflow = 'hidden';
  49. elem.style.width = '0px';
  50. elem.style.height = '0px';
  51. elem.style.border = '0px';
  52. elem.style.outline = 'none';
  53. elem.readonly = true;
  54. elem.disabled = true;
  55. GodotEventListeners.add(elem, 'input', function (evt) {
  56. const c_str = GodotRuntime.allocString(elem.value);
  57. input_cb(c_str, elem.selectionEnd);
  58. GodotRuntime.free(c_str);
  59. }, false);
  60. GodotEventListeners.add(elem, 'blur', function (evt) {
  61. elem.style.display = 'none';
  62. elem.readonly = true;
  63. elem.disabled = true;
  64. }, false);
  65. GodotConfig.canvas.insertAdjacentElement('beforebegin', elem);
  66. return elem;
  67. }
  68. GodotDisplayVK.textinput = create('input');
  69. GodotDisplayVK.textarea = create('textarea');
  70. GodotDisplayVK.updateSize();
  71. },
  72. show: function (text, multiline, start, end) {
  73. if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) {
  74. return;
  75. }
  76. if (GodotDisplayVK.textinput.style.display !== '' || GodotDisplayVK.textarea.style.display !== '') {
  77. GodotDisplayVK.hide();
  78. }
  79. GodotDisplayVK.updateSize();
  80. const elem = multiline ? GodotDisplayVK.textarea : GodotDisplayVK.textinput;
  81. elem.readonly = false;
  82. elem.disabled = false;
  83. elem.value = text;
  84. elem.style.display = 'block';
  85. elem.focus();
  86. elem.setSelectionRange(start, end);
  87. },
  88. hide: function () {
  89. if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) {
  90. return;
  91. }
  92. [GodotDisplayVK.textinput, GodotDisplayVK.textarea].forEach(function (elem) {
  93. elem.blur();
  94. elem.style.display = 'none';
  95. elem.value = '';
  96. });
  97. },
  98. updateSize: function () {
  99. if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) {
  100. return;
  101. }
  102. const rect = GodotConfig.canvas.getBoundingClientRect();
  103. function update(elem) {
  104. elem.style.left = `${rect.left}px`;
  105. elem.style.top = `${rect.top}px`;
  106. elem.style.width = `${rect.width}px`;
  107. elem.style.height = `${rect.height}px`;
  108. }
  109. update(GodotDisplayVK.textinput);
  110. update(GodotDisplayVK.textarea);
  111. },
  112. clear: function () {
  113. if (GodotDisplayVK.textinput) {
  114. GodotDisplayVK.textinput.remove();
  115. GodotDisplayVK.textinput = null;
  116. }
  117. if (GodotDisplayVK.textarea) {
  118. GodotDisplayVK.textarea.remove();
  119. GodotDisplayVK.textarea = null;
  120. }
  121. },
  122. },
  123. };
  124. mergeInto(LibraryManager.library, GodotDisplayVK);
  125. /*
  126. * Display server cursor helper.
  127. * Keeps track of cursor status and custom shapes.
  128. */
  129. const GodotDisplayCursor = {
  130. $GodotDisplayCursor__deps: ['$GodotOS', '$GodotConfig'],
  131. $GodotDisplayCursor__postset: 'GodotOS.atexit(function(resolve, reject) { GodotDisplayCursor.clear(); resolve(); });',
  132. $GodotDisplayCursor: {
  133. shape: 'auto',
  134. visible: true,
  135. cursors: {},
  136. set_style: function (style) {
  137. GodotConfig.canvas.style.cursor = style;
  138. },
  139. set_shape: function (shape) {
  140. GodotDisplayCursor.shape = shape;
  141. let css = shape;
  142. if (shape in GodotDisplayCursor.cursors) {
  143. const c = GodotDisplayCursor.cursors[shape];
  144. css = `url("${c.url}") ${c.x} ${c.y}, auto`;
  145. }
  146. if (GodotDisplayCursor.visible) {
  147. GodotDisplayCursor.set_style(css);
  148. }
  149. },
  150. clear: function () {
  151. GodotDisplayCursor.set_style('');
  152. GodotDisplayCursor.shape = 'auto';
  153. GodotDisplayCursor.visible = true;
  154. Object.keys(GodotDisplayCursor.cursors).forEach(function (key) {
  155. URL.revokeObjectURL(GodotDisplayCursor.cursors[key]);
  156. delete GodotDisplayCursor.cursors[key];
  157. });
  158. },
  159. lockPointer: function () {
  160. const canvas = GodotConfig.canvas;
  161. if (canvas.requestPointerLock) {
  162. canvas.requestPointerLock();
  163. }
  164. },
  165. releasePointer: function () {
  166. if (document.exitPointerLock) {
  167. document.exitPointerLock();
  168. }
  169. },
  170. isPointerLocked: function () {
  171. return document.pointerLockElement === GodotConfig.canvas;
  172. },
  173. },
  174. };
  175. mergeInto(LibraryManager.library, GodotDisplayCursor);
  176. const GodotDisplayScreen = {
  177. $GodotDisplayScreen__deps: ['$GodotConfig', '$GodotOS', '$GL', 'emscripten_webgl_get_current_context'],
  178. $GodotDisplayScreen: {
  179. desired_size: [0, 0],
  180. hidpi: true,
  181. getPixelRatio: function () {
  182. return GodotDisplayScreen.hidpi ? window.devicePixelRatio || 1 : 1;
  183. },
  184. isFullscreen: function () {
  185. const elem = document.fullscreenElement || document.mozFullscreenElement
  186. || document.webkitFullscreenElement || document.msFullscreenElement;
  187. if (elem) {
  188. return elem === GodotConfig.canvas;
  189. }
  190. // But maybe knowing the element is not supported.
  191. return document.fullscreen || document.mozFullScreen
  192. || document.webkitIsFullscreen;
  193. },
  194. hasFullscreen: function () {
  195. return document.fullscreenEnabled || document.mozFullScreenEnabled
  196. || document.webkitFullscreenEnabled;
  197. },
  198. requestFullscreen: function () {
  199. if (!GodotDisplayScreen.hasFullscreen()) {
  200. return 1;
  201. }
  202. const canvas = GodotConfig.canvas;
  203. try {
  204. const promise = (canvas.requestFullscreen || canvas.msRequestFullscreen
  205. || canvas.mozRequestFullScreen || canvas.mozRequestFullscreen
  206. || canvas.webkitRequestFullscreen
  207. ).call(canvas);
  208. // Some browsers (Safari) return undefined.
  209. // For the standard ones, we need to catch it.
  210. if (promise) {
  211. promise.catch(function () {
  212. // nothing to do.
  213. });
  214. }
  215. } catch (e) {
  216. return 1;
  217. }
  218. return 0;
  219. },
  220. exitFullscreen: function () {
  221. if (!GodotDisplayScreen.isFullscreen()) {
  222. return 0;
  223. }
  224. try {
  225. const promise = document.exitFullscreen();
  226. if (promise) {
  227. promise.catch(function () {
  228. // nothing to do.
  229. });
  230. }
  231. } catch (e) {
  232. return 1;
  233. }
  234. return 0;
  235. },
  236. _updateGL: function () {
  237. const gl_context_handle = _emscripten_webgl_get_current_context(); // eslint-disable-line no-undef
  238. const gl = GL.getContext(gl_context_handle);
  239. if (gl) {
  240. GL.resizeOffscreenFramebuffer(gl);
  241. }
  242. },
  243. updateSize: function () {
  244. const isFullscreen = GodotDisplayScreen.isFullscreen();
  245. const wantsFullWindow = GodotConfig.canvas_resize_policy === 2;
  246. const noResize = GodotConfig.canvas_resize_policy === 0;
  247. const wwidth = GodotDisplayScreen.desired_size[0];
  248. const wheight = GodotDisplayScreen.desired_size[1];
  249. const canvas = GodotConfig.canvas;
  250. let width = wwidth;
  251. let height = wheight;
  252. if (noResize) {
  253. // Don't resize canvas, just update GL if needed.
  254. if (canvas.width !== width || canvas.height !== height) {
  255. GodotDisplayScreen.desired_size = [canvas.width, canvas.height];
  256. GodotDisplayScreen._updateGL();
  257. return 1;
  258. }
  259. return 0;
  260. }
  261. const scale = GodotDisplayScreen.getPixelRatio();
  262. if (isFullscreen || wantsFullWindow) {
  263. // We need to match screen size.
  264. width = window.innerWidth * scale;
  265. height = window.innerHeight * scale;
  266. }
  267. const csw = `${width / scale}px`;
  268. const csh = `${height / scale}px`;
  269. if (canvas.style.width !== csw || canvas.style.height !== csh || canvas.width !== width || canvas.height !== height) {
  270. // Size doesn't match.
  271. // Resize canvas, set correct CSS pixel size, update GL.
  272. canvas.width = width;
  273. canvas.height = height;
  274. canvas.style.width = csw;
  275. canvas.style.height = csh;
  276. GodotDisplayScreen._updateGL();
  277. return 1;
  278. }
  279. return 0;
  280. },
  281. },
  282. };
  283. mergeInto(LibraryManager.library, GodotDisplayScreen);
  284. /**
  285. * Display server interface.
  286. *
  287. * Exposes all the functions needed by OS implementation.
  288. */
  289. const GodotDisplay = {
  290. $GodotDisplay__deps: ['$GodotConfig', '$GodotRuntime', '$GodotDisplayCursor', '$GodotEventListeners', '$GodotDisplayScreen', '$GodotDisplayVK'],
  291. $GodotDisplay: {
  292. window_icon: '',
  293. findDPI: function () {
  294. function testDPI(dpi) {
  295. return window.matchMedia(`(max-resolution: ${dpi}dpi)`).matches;
  296. }
  297. function bisect(low, high, func) {
  298. const mid = parseInt(((high - low) / 2) + low, 10);
  299. if (high - low <= 1) {
  300. return func(high) ? high : low;
  301. }
  302. if (func(mid)) {
  303. return bisect(low, mid, func);
  304. }
  305. return bisect(mid, high, func);
  306. }
  307. try {
  308. const dpi = bisect(0, 800, testDPI);
  309. return dpi >= 96 ? dpi : 96;
  310. } catch (e) {
  311. return 96;
  312. }
  313. },
  314. },
  315. // This is implemented as "glGetBufferSubData" in new emscripten versions.
  316. // Since we have to support older (pre 2.0.17) emscripten versions, we add this wrapper function instead.
  317. godot_js_display_glGetBufferSubData__sig: 'viiii',
  318. godot_js_display_glGetBufferSubData__deps: ['$GL', 'emscripten_webgl_get_current_context'],
  319. godot_js_display_glGetBufferSubData: function (target, offset, size, data) {
  320. const gl_context_handle = _emscripten_webgl_get_current_context(); // eslint-disable-line no-undef
  321. const gl = GL.getContext(gl_context_handle);
  322. if (gl) {
  323. gl.GLctx['getBufferSubData'](target, offset, HEAPU8, data, size);
  324. }
  325. },
  326. godot_js_display_is_swap_ok_cancel__sig: 'i',
  327. godot_js_display_is_swap_ok_cancel: function () {
  328. const win = (['Windows', 'Win64', 'Win32', 'WinCE']);
  329. const plat = navigator.platform || '';
  330. if (win.indexOf(plat) !== -1) {
  331. return 1;
  332. }
  333. return 0;
  334. },
  335. godot_js_tts_is_speaking__sig: 'i',
  336. godot_js_tts_is_speaking: function () {
  337. return window.speechSynthesis.speaking;
  338. },
  339. godot_js_tts_is_paused__sig: 'i',
  340. godot_js_tts_is_paused: function () {
  341. return window.speechSynthesis.paused;
  342. },
  343. godot_js_tts_get_voices__sig: 'vi',
  344. godot_js_tts_get_voices: function (p_callback) {
  345. const func = GodotRuntime.get_func(p_callback);
  346. try {
  347. const arr = [];
  348. const voices = window.speechSynthesis.getVoices();
  349. for (let i = 0; i < voices.length; i++) {
  350. arr.push(`${voices[i].lang};${voices[i].name}`);
  351. }
  352. const c_ptr = GodotRuntime.allocStringArray(arr);
  353. func(arr.length, c_ptr);
  354. GodotRuntime.freeStringArray(c_ptr, arr.length);
  355. } catch (e) {
  356. // Fail graciously.
  357. }
  358. },
  359. godot_js_tts_speak__sig: 'viiiffii',
  360. godot_js_tts_speak: function (p_text, p_voice, p_volume, p_pitch, p_rate, p_utterance_id, p_callback) {
  361. const func = GodotRuntime.get_func(p_callback);
  362. function listener_end(evt) {
  363. evt.currentTarget.cb(1 /*TTS_UTTERANCE_ENDED*/, evt.currentTarget.id, 0);
  364. }
  365. function listener_start(evt) {
  366. evt.currentTarget.cb(0 /*TTS_UTTERANCE_STARTED*/, evt.currentTarget.id, 0);
  367. }
  368. function listener_error(evt) {
  369. evt.currentTarget.cb(2 /*TTS_UTTERANCE_CANCELED*/, evt.currentTarget.id, 0);
  370. }
  371. function listener_bound(evt) {
  372. evt.currentTarget.cb(3 /*TTS_UTTERANCE_BOUNDARY*/, evt.currentTarget.id, evt.charIndex);
  373. }
  374. const utterance = new SpeechSynthesisUtterance(GodotRuntime.parseString(p_text));
  375. utterance.rate = p_rate;
  376. utterance.pitch = p_pitch;
  377. utterance.volume = p_volume / 100.0;
  378. utterance.addEventListener('end', listener_end);
  379. utterance.addEventListener('start', listener_start);
  380. utterance.addEventListener('error', listener_error);
  381. utterance.addEventListener('boundary', listener_bound);
  382. utterance.id = p_utterance_id;
  383. utterance.cb = func;
  384. const voice = GodotRuntime.parseString(p_voice);
  385. const voices = window.speechSynthesis.getVoices();
  386. for (let i = 0; i < voices.length; i++) {
  387. if (voices[i].name === voice) {
  388. utterance.voice = voices[i];
  389. break;
  390. }
  391. }
  392. window.speechSynthesis.resume();
  393. window.speechSynthesis.speak(utterance);
  394. },
  395. godot_js_tts_pause__sig: 'v',
  396. godot_js_tts_pause: function () {
  397. window.speechSynthesis.pause();
  398. },
  399. godot_js_tts_resume__sig: 'v',
  400. godot_js_tts_resume: function () {
  401. window.speechSynthesis.resume();
  402. },
  403. godot_js_tts_stop__sig: 'v',
  404. godot_js_tts_stop: function () {
  405. window.speechSynthesis.cancel();
  406. window.speechSynthesis.resume();
  407. },
  408. godot_js_display_alert__sig: 'vi',
  409. godot_js_display_alert: function (p_text) {
  410. window.alert(GodotRuntime.parseString(p_text)); // eslint-disable-line no-alert
  411. },
  412. godot_js_display_screen_dpi_get__sig: 'i',
  413. godot_js_display_screen_dpi_get: function () {
  414. return GodotDisplay.findDPI();
  415. },
  416. godot_js_display_pixel_ratio_get__sig: 'f',
  417. godot_js_display_pixel_ratio_get: function () {
  418. return GodotDisplayScreen.getPixelRatio();
  419. },
  420. godot_js_display_fullscreen_request__sig: 'i',
  421. godot_js_display_fullscreen_request: function () {
  422. return GodotDisplayScreen.requestFullscreen();
  423. },
  424. godot_js_display_fullscreen_exit__sig: 'i',
  425. godot_js_display_fullscreen_exit: function () {
  426. return GodotDisplayScreen.exitFullscreen();
  427. },
  428. godot_js_display_desired_size_set__sig: 'vii',
  429. godot_js_display_desired_size_set: function (width, height) {
  430. GodotDisplayScreen.desired_size = [width, height];
  431. GodotDisplayScreen.updateSize();
  432. },
  433. godot_js_display_size_update__sig: 'i',
  434. godot_js_display_size_update: function () {
  435. const updated = GodotDisplayScreen.updateSize();
  436. if (updated) {
  437. GodotDisplayVK.updateSize();
  438. }
  439. return updated;
  440. },
  441. godot_js_display_screen_size_get__sig: 'vii',
  442. godot_js_display_screen_size_get: function (width, height) {
  443. const scale = GodotDisplayScreen.getPixelRatio();
  444. GodotRuntime.setHeapValue(width, window.screen.width * scale, 'i32');
  445. GodotRuntime.setHeapValue(height, window.screen.height * scale, 'i32');
  446. },
  447. godot_js_display_window_size_get__sig: 'vii',
  448. godot_js_display_window_size_get: function (p_width, p_height) {
  449. GodotRuntime.setHeapValue(p_width, GodotConfig.canvas.width, 'i32');
  450. GodotRuntime.setHeapValue(p_height, GodotConfig.canvas.height, 'i32');
  451. },
  452. godot_js_display_has_webgl__sig: 'ii',
  453. godot_js_display_has_webgl: function (p_version) {
  454. if (p_version !== 1 && p_version !== 2) {
  455. return false;
  456. }
  457. try {
  458. return !!document.createElement('canvas').getContext(p_version === 2 ? 'webgl2' : 'webgl');
  459. } catch (e) { /* Not available */ }
  460. return false;
  461. },
  462. /*
  463. * Canvas
  464. */
  465. godot_js_display_canvas_focus__sig: 'v',
  466. godot_js_display_canvas_focus: function () {
  467. GodotConfig.canvas.focus();
  468. },
  469. godot_js_display_canvas_is_focused__sig: 'i',
  470. godot_js_display_canvas_is_focused: function () {
  471. return document.activeElement === GodotConfig.canvas;
  472. },
  473. /*
  474. * Touchscreen
  475. */
  476. godot_js_display_touchscreen_is_available__sig: 'i',
  477. godot_js_display_touchscreen_is_available: function () {
  478. return 'ontouchstart' in window;
  479. },
  480. /*
  481. * Clipboard
  482. */
  483. godot_js_display_clipboard_set__sig: 'ii',
  484. godot_js_display_clipboard_set: function (p_text) {
  485. const text = GodotRuntime.parseString(p_text);
  486. if (!navigator.clipboard || !navigator.clipboard.writeText) {
  487. return 1;
  488. }
  489. navigator.clipboard.writeText(text).catch(function (e) {
  490. // Setting OS clipboard is only possible from an input callback.
  491. GodotRuntime.error('Setting OS clipboard is only possible from an input callback for the HTML5 plafrom. Exception:', e);
  492. });
  493. return 0;
  494. },
  495. godot_js_display_clipboard_get__sig: 'ii',
  496. godot_js_display_clipboard_get: function (callback) {
  497. const func = GodotRuntime.get_func(callback);
  498. try {
  499. navigator.clipboard.readText().then(function (result) {
  500. const ptr = GodotRuntime.allocString(result);
  501. func(ptr);
  502. GodotRuntime.free(ptr);
  503. }).catch(function (e) {
  504. // Fail graciously.
  505. });
  506. } catch (e) {
  507. // Fail graciously.
  508. }
  509. },
  510. /*
  511. * Window
  512. */
  513. godot_js_display_window_title_set__sig: 'vi',
  514. godot_js_display_window_title_set: function (p_data) {
  515. document.title = GodotRuntime.parseString(p_data);
  516. },
  517. godot_js_display_window_icon_set__sig: 'vii',
  518. godot_js_display_window_icon_set: function (p_ptr, p_len) {
  519. let link = document.getElementById('-gd-engine-icon');
  520. if (link === null) {
  521. link = document.createElement('link');
  522. link.rel = 'icon';
  523. link.id = '-gd-engine-icon';
  524. document.head.appendChild(link);
  525. }
  526. const old_icon = GodotDisplay.window_icon;
  527. const png = new Blob([GodotRuntime.heapSlice(HEAPU8, p_ptr, p_len)], { type: 'image/png' });
  528. GodotDisplay.window_icon = URL.createObjectURL(png);
  529. link.href = GodotDisplay.window_icon;
  530. if (old_icon) {
  531. URL.revokeObjectURL(old_icon);
  532. }
  533. },
  534. /*
  535. * Cursor
  536. */
  537. godot_js_display_cursor_set_visible__sig: 'vi',
  538. godot_js_display_cursor_set_visible: function (p_visible) {
  539. const visible = p_visible !== 0;
  540. if (visible === GodotDisplayCursor.visible) {
  541. return;
  542. }
  543. GodotDisplayCursor.visible = visible;
  544. if (visible) {
  545. GodotDisplayCursor.set_shape(GodotDisplayCursor.shape);
  546. } else {
  547. GodotDisplayCursor.set_style('none');
  548. }
  549. },
  550. godot_js_display_cursor_is_hidden__sig: 'i',
  551. godot_js_display_cursor_is_hidden: function () {
  552. return !GodotDisplayCursor.visible;
  553. },
  554. godot_js_display_cursor_set_shape__sig: 'vi',
  555. godot_js_display_cursor_set_shape: function (p_string) {
  556. GodotDisplayCursor.set_shape(GodotRuntime.parseString(p_string));
  557. },
  558. godot_js_display_cursor_set_custom_shape__sig: 'viiiii',
  559. godot_js_display_cursor_set_custom_shape: function (p_shape, p_ptr, p_len, p_hotspot_x, p_hotspot_y) {
  560. const shape = GodotRuntime.parseString(p_shape);
  561. const old_shape = GodotDisplayCursor.cursors[shape];
  562. if (p_len > 0) {
  563. const png = new Blob([GodotRuntime.heapSlice(HEAPU8, p_ptr, p_len)], { type: 'image/png' });
  564. const url = URL.createObjectURL(png);
  565. GodotDisplayCursor.cursors[shape] = {
  566. url: url,
  567. x: p_hotspot_x,
  568. y: p_hotspot_y,
  569. };
  570. } else {
  571. delete GodotDisplayCursor.cursors[shape];
  572. }
  573. if (shape === GodotDisplayCursor.shape) {
  574. GodotDisplayCursor.set_shape(GodotDisplayCursor.shape);
  575. }
  576. if (old_shape) {
  577. URL.revokeObjectURL(old_shape.url);
  578. }
  579. },
  580. godot_js_display_cursor_lock_set__sig: 'vi',
  581. godot_js_display_cursor_lock_set: function (p_lock) {
  582. if (p_lock) {
  583. GodotDisplayCursor.lockPointer();
  584. } else {
  585. GodotDisplayCursor.releasePointer();
  586. }
  587. },
  588. godot_js_display_cursor_is_locked__sig: 'i',
  589. godot_js_display_cursor_is_locked: function () {
  590. return GodotDisplayCursor.isPointerLocked() ? 1 : 0;
  591. },
  592. /*
  593. * Listeners
  594. */
  595. godot_js_display_fullscreen_cb__sig: 'vi',
  596. godot_js_display_fullscreen_cb: function (callback) {
  597. const canvas = GodotConfig.canvas;
  598. const func = GodotRuntime.get_func(callback);
  599. function change_cb(evt) {
  600. if (evt.target === canvas) {
  601. func(GodotDisplayScreen.isFullscreen());
  602. }
  603. }
  604. GodotEventListeners.add(document, 'fullscreenchange', change_cb, false);
  605. GodotEventListeners.add(document, 'mozfullscreenchange', change_cb, false);
  606. GodotEventListeners.add(document, 'webkitfullscreenchange', change_cb, false);
  607. },
  608. godot_js_display_window_blur_cb__sig: 'vi',
  609. godot_js_display_window_blur_cb: function (callback) {
  610. const func = GodotRuntime.get_func(callback);
  611. GodotEventListeners.add(window, 'blur', function () {
  612. func();
  613. }, false);
  614. },
  615. godot_js_display_notification_cb__sig: 'viiiii',
  616. godot_js_display_notification_cb: function (callback, p_enter, p_exit, p_in, p_out) {
  617. const canvas = GodotConfig.canvas;
  618. const func = GodotRuntime.get_func(callback);
  619. const notif = [p_enter, p_exit, p_in, p_out];
  620. ['mouseover', 'mouseleave', 'focus', 'blur'].forEach(function (evt_name, idx) {
  621. GodotEventListeners.add(canvas, evt_name, function () {
  622. func(notif[idx]);
  623. }, true);
  624. });
  625. },
  626. godot_js_display_setup_canvas__sig: 'viiii',
  627. godot_js_display_setup_canvas: function (p_width, p_height, p_fullscreen, p_hidpi) {
  628. const canvas = GodotConfig.canvas;
  629. GodotEventListeners.add(canvas, 'contextmenu', function (ev) {
  630. ev.preventDefault();
  631. }, false);
  632. GodotEventListeners.add(canvas, 'webglcontextlost', function (ev) {
  633. alert('WebGL context lost, please reload the page'); // eslint-disable-line no-alert
  634. ev.preventDefault();
  635. }, false);
  636. GodotDisplayScreen.hidpi = !!p_hidpi;
  637. switch (GodotConfig.canvas_resize_policy) {
  638. case 0: // None
  639. GodotDisplayScreen.desired_size = [canvas.width, canvas.height];
  640. break;
  641. case 1: // Project
  642. GodotDisplayScreen.desired_size = [p_width, p_height];
  643. break;
  644. default: // Full window
  645. // Ensure we display in the right place, the size will be handled by updateSize
  646. canvas.style.position = 'absolute';
  647. canvas.style.top = 0;
  648. canvas.style.left = 0;
  649. break;
  650. }
  651. GodotDisplayScreen.updateSize();
  652. if (p_fullscreen) {
  653. GodotDisplayScreen.requestFullscreen();
  654. }
  655. },
  656. /*
  657. * Virtual Keyboard
  658. */
  659. godot_js_display_vk_show__sig: 'viiii',
  660. godot_js_display_vk_show: function (p_text, p_multiline, p_start, p_end) {
  661. const text = GodotRuntime.parseString(p_text);
  662. const start = p_start > 0 ? p_start : 0;
  663. const end = p_end > 0 ? p_end : start;
  664. GodotDisplayVK.show(text, p_multiline, start, end);
  665. },
  666. godot_js_display_vk_hide__sig: 'v',
  667. godot_js_display_vk_hide: function () {
  668. GodotDisplayVK.hide();
  669. },
  670. godot_js_display_vk_available__sig: 'i',
  671. godot_js_display_vk_available: function () {
  672. return GodotDisplayVK.available();
  673. },
  674. godot_js_display_tts_available__sig: 'i',
  675. godot_js_display_tts_available: function () {
  676. return 'speechSynthesis' in window;
  677. },
  678. godot_js_display_vk_cb__sig: 'vi',
  679. godot_js_display_vk_cb: function (p_input_cb) {
  680. const input_cb = GodotRuntime.get_func(p_input_cb);
  681. if (GodotDisplayVK.available()) {
  682. GodotDisplayVK.init(input_cb);
  683. }
  684. },
  685. };
  686. autoAddDeps(GodotDisplay, '$GodotDisplay');
  687. mergeInto(LibraryManager.library, GodotDisplay);