os_javascript.cpp 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237
  1. /*************************************************************************/
  2. /* os_javascript.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "os_javascript.h"
  31. #include "core/io/json.h"
  32. #include "drivers/gles2/rasterizer_gles2.h"
  33. #include "drivers/gles3/rasterizer_gles3.h"
  34. #include "drivers/unix/dir_access_unix.h"
  35. #include "drivers/unix/file_access_unix.h"
  36. #include "main/main.h"
  37. #include "servers/visual/visual_server_raster.h"
  38. #ifndef NO_THREADS
  39. #include "servers/visual/visual_server_wrap_mt.h"
  40. #endif
  41. #include <dlfcn.h>
  42. #include <emscripten.h>
  43. #include <png.h>
  44. #include <stdlib.h>
  45. #include "dom_keys.inc"
  46. #include "godot_js.h"
  47. #define DOM_BUTTON_LEFT 0
  48. #define DOM_BUTTON_MIDDLE 1
  49. #define DOM_BUTTON_RIGHT 2
  50. #define DOM_BUTTON_XBUTTON1 3
  51. #define DOM_BUTTON_XBUTTON2 4
  52. // Quit
  53. void OS_JavaScript::request_quit_callback() {
  54. OS_JavaScript *os = get_singleton();
  55. if (os && os->get_main_loop()) {
  56. os->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
  57. }
  58. }
  59. // Files drop (implemented in JS for now).
  60. void OS_JavaScript::drop_files_callback(char **p_filev, int p_filec) {
  61. OS_JavaScript *os = get_singleton();
  62. if (!os || !os->get_main_loop()) {
  63. return;
  64. }
  65. Vector<String> files;
  66. for (int i = 0; i < p_filec; i++) {
  67. files.push_back(String::utf8(p_filev[i]));
  68. }
  69. os->get_main_loop()->drop_files(files);
  70. }
  71. void OS_JavaScript::send_notification_callback(int p_notification) {
  72. OS_JavaScript *os = get_singleton();
  73. if (!os) {
  74. return;
  75. }
  76. if (p_notification == MainLoop::NOTIFICATION_WM_MOUSE_ENTER || p_notification == MainLoop::NOTIFICATION_WM_MOUSE_EXIT) {
  77. os->cursor_inside_canvas = p_notification == MainLoop::NOTIFICATION_WM_MOUSE_ENTER;
  78. }
  79. MainLoop *loop = os->get_main_loop();
  80. if (loop) {
  81. loop->notification(p_notification);
  82. }
  83. }
  84. // Window (canvas)
  85. Point2 OS_JavaScript::compute_position_in_canvas(int p_x, int p_y) {
  86. int point[2];
  87. godot_js_display_compute_position(p_x, p_y, point, point + 1);
  88. return Point2(point[0], point[1]);
  89. }
  90. bool OS_JavaScript::check_size_force_redraw() {
  91. return godot_js_display_size_update() != 0;
  92. }
  93. EM_BOOL OS_JavaScript::fullscreen_change_callback(int p_event_type, const EmscriptenFullscreenChangeEvent *p_event, void *p_user_data) {
  94. OS_JavaScript *os = get_singleton();
  95. // Empty ID is canvas.
  96. String target_id = String::utf8(p_event->id);
  97. if (target_id.empty() || target_id == String::utf8(&(os->canvas_id[1]))) {
  98. // This event property is the only reliable data on
  99. // browser fullscreen state.
  100. os->video_mode.fullscreen = p_event->isFullscreen;
  101. if (os->video_mode.fullscreen) {
  102. os->entering_fullscreen = false;
  103. } else {
  104. // Restoring maximized window now will cause issues,
  105. // so delay until main_loop_iterate.
  106. os->just_exited_fullscreen = true;
  107. }
  108. }
  109. return false;
  110. }
  111. void OS_JavaScript::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
  112. video_mode = p_video_mode;
  113. }
  114. OS::VideoMode OS_JavaScript::get_video_mode(int p_screen) const {
  115. return video_mode;
  116. }
  117. Size2 OS_JavaScript::get_screen_size(int p_screen) const {
  118. int size[2];
  119. godot_js_display_screen_size_get(size, size + 1);
  120. return Size2(size[0], size[1]);
  121. }
  122. void OS_JavaScript::set_window_size(const Size2 p_size) {
  123. if (video_mode.fullscreen) {
  124. window_maximized = false;
  125. set_window_fullscreen(false);
  126. } else {
  127. if (window_maximized) {
  128. emscripten_exit_soft_fullscreen();
  129. window_maximized = false;
  130. }
  131. godot_js_display_desired_size_set(p_size.x, p_size.y);
  132. }
  133. }
  134. Size2 OS_JavaScript::get_window_size() const {
  135. int size[2];
  136. godot_js_display_window_size_get(size, size + 1);
  137. return Size2(size[0], size[1]);
  138. }
  139. void OS_JavaScript::set_window_maximized(bool p_enabled) {
  140. #ifndef TOOLS_ENABLED
  141. if (video_mode.fullscreen) {
  142. window_maximized = p_enabled;
  143. set_window_fullscreen(false);
  144. } else if (!p_enabled) {
  145. emscripten_exit_soft_fullscreen();
  146. window_maximized = false;
  147. } else if (!window_maximized) {
  148. // Prevent calling emscripten_enter_soft_fullscreen mutltiple times,
  149. // this would hide page elements permanently.
  150. EmscriptenFullscreenStrategy strategy;
  151. strategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
  152. strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
  153. strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
  154. strategy.canvasResizedCallback = NULL;
  155. emscripten_enter_soft_fullscreen(canvas_id, &strategy);
  156. window_maximized = p_enabled;
  157. }
  158. #endif
  159. }
  160. bool OS_JavaScript::is_window_maximized() const {
  161. return window_maximized;
  162. }
  163. void OS_JavaScript::set_window_fullscreen(bool p_enabled) {
  164. if (p_enabled == video_mode.fullscreen) {
  165. return;
  166. }
  167. // Just request changes here, if successful, logic continues in
  168. // fullscreen_change_callback.
  169. if (p_enabled) {
  170. if (window_maximized) {
  171. // Soft fullsreen during real fullscreen can cause issues, so exit.
  172. // This must be called before requesting full screen.
  173. emscripten_exit_soft_fullscreen();
  174. }
  175. int result = godot_js_display_fullscreen_request();
  176. ERR_FAIL_COND_MSG(result, "The request was denied. Remember that enabling fullscreen is only possible from an input callback for the HTML5 platform.");
  177. entering_fullscreen = true;
  178. } else {
  179. // No logic allowed here, since exiting w/ ESC key won't use this function.
  180. ERR_FAIL_COND(godot_js_display_fullscreen_exit());
  181. }
  182. }
  183. bool OS_JavaScript::is_window_fullscreen() const {
  184. return video_mode.fullscreen;
  185. }
  186. void OS_JavaScript::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
  187. Size2 screen = get_screen_size();
  188. p_list->push_back(OS::VideoMode(screen.width, screen.height, true));
  189. }
  190. bool OS_JavaScript::get_window_per_pixel_transparency_enabled() const {
  191. if (!is_layered_allowed()) {
  192. return false;
  193. }
  194. return transparency_enabled;
  195. }
  196. void OS_JavaScript::set_window_per_pixel_transparency_enabled(bool p_enabled) {
  197. if (!is_layered_allowed()) {
  198. return;
  199. }
  200. transparency_enabled = p_enabled;
  201. }
  202. // Keys
  203. template <typename T>
  204. static void dom2godot_mod(T *emscripten_event_ptr, Ref<InputEventWithModifiers> godot_event) {
  205. godot_event->set_shift(emscripten_event_ptr->shiftKey);
  206. godot_event->set_alt(emscripten_event_ptr->altKey);
  207. godot_event->set_control(emscripten_event_ptr->ctrlKey);
  208. godot_event->set_metakey(emscripten_event_ptr->metaKey);
  209. }
  210. static Ref<InputEventKey> setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) {
  211. Ref<InputEventKey> ev;
  212. ev.instance();
  213. ev->set_echo(emscripten_event->repeat);
  214. dom2godot_mod(emscripten_event, ev);
  215. ev->set_scancode(dom_code2godot_scancode(emscripten_event->code, emscripten_event->key, false));
  216. ev->set_physical_scancode(dom_code2godot_scancode(emscripten_event->code, emscripten_event->key, true));
  217. String unicode = String::utf8(emscripten_event->key);
  218. // Check if empty or multi-character (e.g. `CapsLock`).
  219. if (unicode.length() != 1) {
  220. // Might be empty as well, but better than nonsense.
  221. unicode = String::utf8(emscripten_event->charValue);
  222. }
  223. if (unicode.length() == 1) {
  224. ev->set_unicode(unicode[0]);
  225. }
  226. return ev;
  227. }
  228. EM_BOOL OS_JavaScript::keydown_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  229. OS_JavaScript *os = get_singleton();
  230. Ref<InputEventKey> ev = setup_key_event(p_event);
  231. ev->set_pressed(true);
  232. if (ev->get_unicode() == 0 && keycode_has_unicode(ev->get_scancode())) {
  233. // Defer to keypress event for legacy unicode retrieval.
  234. os->deferred_key_event = ev;
  235. // Do not suppress keypress event.
  236. return false;
  237. }
  238. os->input->parse_input_event(ev);
  239. // Make sure to flush all events so we can call restricted APIs inside the event.
  240. os->input->flush_buffered_events();
  241. // Resume audio context after input in case autoplay was denied.
  242. os->resume_audio();
  243. return true;
  244. }
  245. EM_BOOL OS_JavaScript::keypress_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  246. OS_JavaScript *os = get_singleton();
  247. os->deferred_key_event->set_unicode(p_event->charCode);
  248. os->input->parse_input_event(os->deferred_key_event);
  249. // Make sure to flush all events so we can call restricted APIs inside the event.
  250. os->input->flush_buffered_events();
  251. return true;
  252. }
  253. EM_BOOL OS_JavaScript::keyup_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  254. OS_JavaScript *os = get_singleton();
  255. Ref<InputEventKey> ev = setup_key_event(p_event);
  256. ev->set_pressed(false);
  257. os->input->parse_input_event(ev);
  258. // Make sure to flush all events so we can call restricted APIs inside the event.
  259. os->input->flush_buffered_events();
  260. return ev->get_scancode() != KEY_UNKNOWN && ev->get_scancode() != 0;
  261. }
  262. // Mouse
  263. Point2 OS_JavaScript::get_mouse_position() const {
  264. return input->get_mouse_position();
  265. }
  266. int OS_JavaScript::get_mouse_button_state() const {
  267. return input->get_mouse_button_mask();
  268. }
  269. EM_BOOL OS_JavaScript::mouse_button_callback(int p_event_type, const EmscriptenMouseEvent *p_event, void *p_user_data) {
  270. OS_JavaScript *os = get_singleton();
  271. Ref<InputEventMouseButton> ev;
  272. ev.instance();
  273. ev->set_pressed(p_event_type == EMSCRIPTEN_EVENT_MOUSEDOWN);
  274. ev->set_position(compute_position_in_canvas(p_event->clientX, p_event->clientY));
  275. ev->set_global_position(ev->get_position());
  276. dom2godot_mod(p_event, ev);
  277. switch (p_event->button) {
  278. case DOM_BUTTON_LEFT:
  279. ev->set_button_index(BUTTON_LEFT);
  280. break;
  281. case DOM_BUTTON_MIDDLE:
  282. ev->set_button_index(BUTTON_MIDDLE);
  283. break;
  284. case DOM_BUTTON_RIGHT:
  285. ev->set_button_index(BUTTON_RIGHT);
  286. break;
  287. case DOM_BUTTON_XBUTTON1:
  288. ev->set_button_index(BUTTON_XBUTTON1);
  289. break;
  290. case DOM_BUTTON_XBUTTON2:
  291. ev->set_button_index(BUTTON_XBUTTON2);
  292. break;
  293. default:
  294. return false;
  295. }
  296. if (ev->is_pressed()) {
  297. double diff = emscripten_get_now() - os->last_click_ms;
  298. if (ev->get_button_index() == os->last_click_button_index) {
  299. if (diff < 400 && Point2(os->last_click_pos).distance_to(ev->get_position()) < 5) {
  300. os->last_click_ms = 0;
  301. os->last_click_pos = Point2(-100, -100);
  302. os->last_click_button_index = -1;
  303. ev->set_doubleclick(true);
  304. }
  305. } else {
  306. os->last_click_button_index = ev->get_button_index();
  307. }
  308. if (!ev->is_doubleclick()) {
  309. os->last_click_ms += diff;
  310. os->last_click_pos = ev->get_position();
  311. }
  312. }
  313. int mask = os->input->get_mouse_button_mask();
  314. int button_flag = 1 << (ev->get_button_index() - 1);
  315. if (ev->is_pressed()) {
  316. // Since the event is consumed, focus manually. The containing iframe,
  317. // if exists, may not have focus yet, so focus even if already focused.
  318. godot_js_display_canvas_focus();
  319. mask |= button_flag;
  320. } else if (mask & button_flag) {
  321. mask &= ~button_flag;
  322. } else {
  323. // Received release event, but press was outside the canvas, so ignore.
  324. return false;
  325. }
  326. ev->set_button_mask(mask);
  327. os->input->parse_input_event(ev);
  328. // Make sure to flush all events so we can call restricted APIs inside the event.
  329. os->input->flush_buffered_events();
  330. // Resume audio context after input in case autoplay was denied.
  331. os->resume_audio();
  332. // Prevent multi-click text selection and wheel-click scrolling anchor.
  333. // Context menu is prevented through contextmenu event.
  334. return true;
  335. }
  336. EM_BOOL OS_JavaScript::mousemove_callback(int p_event_type, const EmscriptenMouseEvent *p_event, void *p_user_data) {
  337. OS_JavaScript *os = get_singleton();
  338. int input_mask = os->input->get_mouse_button_mask();
  339. Point2 pos = compute_position_in_canvas(p_event->clientX, p_event->clientY);
  340. // For motion outside the canvas, only read mouse movement if dragging
  341. // started inside the canvas; imitating desktop app behaviour.
  342. if (!os->cursor_inside_canvas && !input_mask)
  343. return false;
  344. Ref<InputEventMouseMotion> ev;
  345. ev.instance();
  346. dom2godot_mod(p_event, ev);
  347. ev->set_button_mask(input_mask);
  348. ev->set_position(pos);
  349. ev->set_global_position(ev->get_position());
  350. ev->set_relative(Vector2(p_event->movementX, p_event->movementY));
  351. os->input->set_mouse_position(ev->get_position());
  352. ev->set_speed(os->input->get_last_mouse_speed());
  353. os->input->parse_input_event(ev);
  354. // Don't suppress mouseover/-leave events.
  355. return false;
  356. }
  357. static const char *godot2dom_cursor(OS::CursorShape p_shape) {
  358. switch (p_shape) {
  359. case OS::CURSOR_ARROW:
  360. default:
  361. return "auto";
  362. case OS::CURSOR_IBEAM:
  363. return "text";
  364. case OS::CURSOR_POINTING_HAND:
  365. return "pointer";
  366. case OS::CURSOR_CROSS:
  367. return "crosshair";
  368. case OS::CURSOR_WAIT:
  369. return "progress";
  370. case OS::CURSOR_BUSY:
  371. return "wait";
  372. case OS::CURSOR_DRAG:
  373. return "grab";
  374. case OS::CURSOR_CAN_DROP:
  375. return "grabbing";
  376. case OS::CURSOR_FORBIDDEN:
  377. return "no-drop";
  378. case OS::CURSOR_VSIZE:
  379. return "ns-resize";
  380. case OS::CURSOR_HSIZE:
  381. return "ew-resize";
  382. case OS::CURSOR_BDIAGSIZE:
  383. return "nesw-resize";
  384. case OS::CURSOR_FDIAGSIZE:
  385. return "nwse-resize";
  386. case OS::CURSOR_MOVE:
  387. return "move";
  388. case OS::CURSOR_VSPLIT:
  389. return "row-resize";
  390. case OS::CURSOR_HSPLIT:
  391. return "col-resize";
  392. case OS::CURSOR_HELP:
  393. return "help";
  394. }
  395. }
  396. void OS_JavaScript::set_cursor_shape(CursorShape p_shape) {
  397. ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
  398. if (cursor_shape == p_shape) {
  399. return;
  400. }
  401. cursor_shape = p_shape;
  402. godot_js_display_cursor_set_shape(godot2dom_cursor(cursor_shape));
  403. }
  404. void OS_JavaScript::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
  405. if (p_cursor.is_valid()) {
  406. Ref<Texture> texture = p_cursor;
  407. Ref<AtlasTexture> atlas_texture = p_cursor;
  408. Ref<Image> image;
  409. Size2 texture_size;
  410. Rect2 atlas_rect;
  411. if (texture.is_valid()) {
  412. image = texture->get_data();
  413. if (image.is_valid()) {
  414. image->duplicate();
  415. }
  416. }
  417. if (!image.is_valid() && atlas_texture.is_valid()) {
  418. texture = atlas_texture->get_atlas();
  419. atlas_rect.size.width = texture->get_width();
  420. atlas_rect.size.height = texture->get_height();
  421. atlas_rect.position.x = atlas_texture->get_region().position.x;
  422. atlas_rect.position.y = atlas_texture->get_region().position.y;
  423. texture_size.width = atlas_texture->get_region().size.x;
  424. texture_size.height = atlas_texture->get_region().size.y;
  425. } else if (image.is_valid()) {
  426. texture_size.width = texture->get_width();
  427. texture_size.height = texture->get_height();
  428. }
  429. ERR_FAIL_COND(!texture.is_valid());
  430. ERR_FAIL_COND(p_hotspot.x < 0 || p_hotspot.y < 0);
  431. ERR_FAIL_COND(texture_size.width > 256 || texture_size.height > 256);
  432. ERR_FAIL_COND(p_hotspot.x > texture_size.width || p_hotspot.y > texture_size.height);
  433. image = texture->get_data();
  434. ERR_FAIL_COND(!image.is_valid());
  435. image = image->duplicate();
  436. if (atlas_texture.is_valid())
  437. image->crop_from_point(
  438. atlas_rect.position.x,
  439. atlas_rect.position.y,
  440. texture_size.width,
  441. texture_size.height);
  442. if (image->get_format() != Image::FORMAT_RGBA8) {
  443. image->convert(Image::FORMAT_RGBA8);
  444. }
  445. png_image png_meta;
  446. memset(&png_meta, 0, sizeof png_meta);
  447. png_meta.version = PNG_IMAGE_VERSION;
  448. png_meta.width = texture_size.width;
  449. png_meta.height = texture_size.height;
  450. png_meta.format = PNG_FORMAT_RGBA;
  451. PoolByteArray png;
  452. size_t len;
  453. PoolByteArray::Read r = image->get_data().read();
  454. ERR_FAIL_COND(!png_image_write_get_memory_size(png_meta, len, 0, r.ptr(), 0, NULL));
  455. png.resize(len);
  456. PoolByteArray::Write w = png.write();
  457. ERR_FAIL_COND(!png_image_write_to_memory(&png_meta, w.ptr(), &len, 0, r.ptr(), 0, NULL));
  458. w = PoolByteArray::Write();
  459. r = png.read();
  460. godot_js_display_cursor_set_custom_shape(godot2dom_cursor(p_shape), r.ptr(), len, p_hotspot.x, p_hotspot.y);
  461. r = PoolByteArray::Read();
  462. } else {
  463. godot_js_display_cursor_set_custom_shape(godot2dom_cursor(p_shape), NULL, 0, 0, 0);
  464. }
  465. }
  466. void OS_JavaScript::set_mouse_mode(OS::MouseMode p_mode) {
  467. ERR_FAIL_COND_MSG(p_mode == MOUSE_MODE_CONFINED, "MOUSE_MODE_CONFINED is not supported for the HTML5 platform.");
  468. if (p_mode == get_mouse_mode())
  469. return;
  470. if (p_mode == MOUSE_MODE_VISIBLE) {
  471. godot_js_display_cursor_set_visible(1);
  472. emscripten_exit_pointerlock();
  473. } else if (p_mode == MOUSE_MODE_HIDDEN) {
  474. godot_js_display_cursor_set_visible(0);
  475. emscripten_exit_pointerlock();
  476. } else if (p_mode == MOUSE_MODE_CAPTURED) {
  477. godot_js_display_cursor_set_visible(1);
  478. EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(canvas_id, false);
  479. ERR_FAIL_COND_MSG(result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED, "MOUSE_MODE_CAPTURED can only be entered from within an appropriate input callback.");
  480. ERR_FAIL_COND_MSG(result != EMSCRIPTEN_RESULT_SUCCESS, "MOUSE_MODE_CAPTURED can only be entered from within an appropriate input callback.");
  481. }
  482. }
  483. OS::MouseMode OS_JavaScript::get_mouse_mode() const {
  484. if (godot_js_display_cursor_is_hidden())
  485. return MOUSE_MODE_HIDDEN;
  486. EmscriptenPointerlockChangeEvent ev;
  487. emscripten_get_pointerlock_status(&ev);
  488. return (ev.isActive && String::utf8(ev.id) == String::utf8(&canvas_id[1])) ? MOUSE_MODE_CAPTURED : MOUSE_MODE_VISIBLE;
  489. }
  490. // Wheel
  491. EM_BOOL OS_JavaScript::wheel_callback(int p_event_type, const EmscriptenWheelEvent *p_event, void *p_user_data) {
  492. ERR_FAIL_COND_V(p_event_type != EMSCRIPTEN_EVENT_WHEEL, false);
  493. OS_JavaScript *os = get_singleton();
  494. if (!godot_js_display_canvas_is_focused()) {
  495. if (os->cursor_inside_canvas) {
  496. godot_js_display_canvas_focus();
  497. } else {
  498. return false;
  499. }
  500. }
  501. InputDefault *input = os->input;
  502. Ref<InputEventMouseButton> ev;
  503. ev.instance();
  504. ev->set_position(input->get_mouse_position());
  505. ev->set_global_position(ev->get_position());
  506. ev->set_shift(input->is_key_pressed(KEY_SHIFT));
  507. ev->set_alt(input->is_key_pressed(KEY_ALT));
  508. ev->set_control(input->is_key_pressed(KEY_CONTROL));
  509. ev->set_metakey(input->is_key_pressed(KEY_META));
  510. if (p_event->deltaY < 0)
  511. ev->set_button_index(BUTTON_WHEEL_UP);
  512. else if (p_event->deltaY > 0)
  513. ev->set_button_index(BUTTON_WHEEL_DOWN);
  514. else if (p_event->deltaX > 0)
  515. ev->set_button_index(BUTTON_WHEEL_LEFT);
  516. else if (p_event->deltaX < 0)
  517. ev->set_button_index(BUTTON_WHEEL_RIGHT);
  518. else
  519. return false;
  520. // Different browsers give wildly different delta values, and we can't
  521. // interpret deltaMode, so use default value for wheel events' factor.
  522. int button_flag = 1 << (ev->get_button_index() - 1);
  523. ev->set_pressed(true);
  524. ev->set_button_mask(input->get_mouse_button_mask() | button_flag);
  525. input->parse_input_event(ev);
  526. Ref<InputEventMouseButton> release = ev->duplicate();
  527. release->set_pressed(false);
  528. release->set_button_mask(input->get_mouse_button_mask() & ~button_flag);
  529. input->parse_input_event(release);
  530. return true;
  531. }
  532. // Touch
  533. bool OS_JavaScript::has_touchscreen_ui_hint() const {
  534. return godot_js_display_touchscreen_is_available();
  535. }
  536. EM_BOOL OS_JavaScript::touch_press_callback(int p_event_type, const EmscriptenTouchEvent *p_event, void *p_user_data) {
  537. OS_JavaScript *os = get_singleton();
  538. Ref<InputEventScreenTouch> ev;
  539. int lowest_id_index = -1;
  540. for (int i = 0; i < p_event->numTouches; ++i) {
  541. const EmscriptenTouchPoint &touch = p_event->touches[i];
  542. if (lowest_id_index == -1 || touch.identifier < p_event->touches[lowest_id_index].identifier)
  543. lowest_id_index = i;
  544. if (!touch.isChanged)
  545. continue;
  546. ev.instance();
  547. ev->set_index(touch.identifier);
  548. ev->set_position(compute_position_in_canvas(touch.clientX, touch.clientY));
  549. os->touches[i] = ev->get_position();
  550. ev->set_pressed(p_event_type == EMSCRIPTEN_EVENT_TOUCHSTART);
  551. os->input->parse_input_event(ev);
  552. }
  553. // Make sure to flush all events so we can call restricted APIs inside the event.
  554. os->input->flush_buffered_events();
  555. // Resume audio context after input in case autoplay was denied.
  556. os->resume_audio();
  557. return true;
  558. }
  559. EM_BOOL OS_JavaScript::touchmove_callback(int p_event_type, const EmscriptenTouchEvent *p_event, void *p_user_data) {
  560. OS_JavaScript *os = get_singleton();
  561. Ref<InputEventScreenDrag> ev;
  562. int lowest_id_index = -1;
  563. for (int i = 0; i < p_event->numTouches; ++i) {
  564. const EmscriptenTouchPoint &touch = p_event->touches[i];
  565. if (lowest_id_index == -1 || touch.identifier < p_event->touches[lowest_id_index].identifier)
  566. lowest_id_index = i;
  567. if (!touch.isChanged)
  568. continue;
  569. ev.instance();
  570. ev->set_index(touch.identifier);
  571. ev->set_position(compute_position_in_canvas(touch.clientX, touch.clientY));
  572. Point2 &prev = os->touches[i];
  573. ev->set_relative(ev->get_position() - prev);
  574. prev = ev->get_position();
  575. os->input->parse_input_event(ev);
  576. }
  577. return true;
  578. }
  579. // Gamepad
  580. void OS_JavaScript::gamepad_callback(int p_index, int p_connected, const char *p_id, const char *p_guid) {
  581. InputDefault *input = get_singleton()->input;
  582. if (p_connected) {
  583. input->joy_connection_changed(p_index, true, String::utf8(p_id), String::utf8(p_guid));
  584. } else {
  585. input->joy_connection_changed(p_index, false, "");
  586. }
  587. }
  588. void OS_JavaScript::process_joypads() {
  589. int32_t pads = godot_js_display_gamepad_sample_count();
  590. int32_t s_btns_num = 0;
  591. int32_t s_axes_num = 0;
  592. int32_t s_standard = 0;
  593. float s_btns[16];
  594. float s_axes[10];
  595. for (int idx = 0; idx < pads; idx++) {
  596. int err = godot_js_display_gamepad_sample_get(idx, s_btns, &s_btns_num, s_axes, &s_axes_num, &s_standard);
  597. if (err) {
  598. continue;
  599. }
  600. for (int b = 0; b < s_btns_num; b++) {
  601. float value = s_btns[b];
  602. // Buttons 6 and 7 in the standard mapping need to be
  603. // axis to be handled as JOY_ANALOG by Godot.
  604. if (s_standard && (b == 6 || b == 7)) {
  605. InputDefault::JoyAxis joy_axis;
  606. joy_axis.min = 0;
  607. joy_axis.value = value;
  608. int a = b == 6 ? JOY_ANALOG_L2 : JOY_ANALOG_R2;
  609. input->joy_axis(idx, a, joy_axis);
  610. } else {
  611. input->joy_button(idx, b, value);
  612. }
  613. }
  614. for (int a = 0; a < s_axes_num; a++) {
  615. InputDefault::JoyAxis joy_axis;
  616. joy_axis.min = -1;
  617. joy_axis.value = s_axes[a];
  618. input->joy_axis(idx, a, joy_axis);
  619. }
  620. }
  621. }
  622. bool OS_JavaScript::is_joy_known(int p_device) {
  623. return input->is_joy_mapped(p_device);
  624. }
  625. String OS_JavaScript::get_joy_guid(int p_device) const {
  626. return input->get_joy_guid_remapped(p_device);
  627. }
  628. // Video
  629. int OS_JavaScript::get_video_driver_count() const {
  630. return VIDEO_DRIVER_MAX;
  631. }
  632. const char *OS_JavaScript::get_video_driver_name(int p_driver) const {
  633. switch (p_driver) {
  634. case VIDEO_DRIVER_GLES3:
  635. return "GLES3";
  636. case VIDEO_DRIVER_GLES2:
  637. return "GLES2";
  638. }
  639. ERR_FAIL_V_MSG(NULL, "Invalid video driver index: " + itos(p_driver) + ".");
  640. }
  641. // Audio
  642. int OS_JavaScript::get_audio_driver_count() const {
  643. return 1;
  644. }
  645. const char *OS_JavaScript::get_audio_driver_name(int p_driver) const {
  646. return "JavaScript";
  647. }
  648. // Clipboard
  649. void OS_JavaScript::update_clipboard_callback(const char *p_text) {
  650. // Only call set_clipboard from OS (sets local clipboard)
  651. get_singleton()->OS::set_clipboard(p_text);
  652. }
  653. void OS_JavaScript::set_clipboard(const String &p_text) {
  654. OS::set_clipboard(p_text);
  655. int err = godot_js_display_clipboard_set(p_text.utf8().get_data());
  656. ERR_FAIL_COND_MSG(err, "Clipboard API is not supported.");
  657. }
  658. String OS_JavaScript::get_clipboard() const {
  659. godot_js_display_clipboard_get(update_clipboard_callback);
  660. return this->OS::get_clipboard();
  661. }
  662. // Lifecycle
  663. int OS_JavaScript::get_current_video_driver() const {
  664. return video_driver_index;
  665. }
  666. void OS_JavaScript::initialize_core() {
  667. OS_Unix::initialize_core();
  668. }
  669. Error OS_JavaScript::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
  670. video_mode = p_desired;
  671. // fullscreen_change_callback will correct this if the request is successful.
  672. video_mode.fullscreen = false;
  673. // Handle contextmenu, webglcontextlost, initial canvas setup.
  674. godot_js_display_setup_canvas(video_mode.width, video_mode.height, video_mode.fullscreen, is_hidpi_allowed() ? 1 : 0);
  675. swap_ok_cancel = godot_js_display_is_swap_ok_cancel() == 1;
  676. EmscriptenWebGLContextAttributes attributes;
  677. emscripten_webgl_init_context_attributes(&attributes);
  678. attributes.alpha = GLOBAL_GET("display/window/per_pixel_transparency/allowed");
  679. attributes.antialias = false;
  680. attributes.explicitSwapControl = true;
  681. ERR_FAIL_INDEX_V(p_video_driver, VIDEO_DRIVER_MAX, ERR_INVALID_PARAMETER);
  682. if (p_desired.layered) {
  683. set_window_per_pixel_transparency_enabled(true);
  684. }
  685. #ifdef TOOLS_ENABLED
  686. bool gles3 = false;
  687. #else
  688. bool gles3 = true;
  689. if (p_video_driver == VIDEO_DRIVER_GLES2) {
  690. gles3 = false;
  691. }
  692. #endif
  693. bool gl_initialization_error = false;
  694. while (true) {
  695. if (gles3) {
  696. if (godot_js_display_has_webgl(2) && RasterizerGLES3::is_viable() == OK) {
  697. attributes.majorVersion = 2;
  698. RasterizerGLES3::register_config();
  699. RasterizerGLES3::make_current();
  700. break;
  701. } else {
  702. if (GLOBAL_GET("rendering/quality/driver/fallback_to_gles2")) {
  703. p_video_driver = VIDEO_DRIVER_GLES2;
  704. gles3 = false;
  705. continue;
  706. } else {
  707. gl_initialization_error = true;
  708. break;
  709. }
  710. }
  711. } else {
  712. if (godot_js_display_has_webgl(1) && RasterizerGLES2::is_viable() == OK) {
  713. attributes.majorVersion = 1;
  714. RasterizerGLES2::register_config();
  715. RasterizerGLES2::make_current();
  716. break;
  717. } else {
  718. gl_initialization_error = true;
  719. break;
  720. }
  721. }
  722. }
  723. webgl_ctx = emscripten_webgl_create_context(canvas_id, &attributes);
  724. if (emscripten_webgl_make_context_current(webgl_ctx) != EMSCRIPTEN_RESULT_SUCCESS) {
  725. gl_initialization_error = true;
  726. }
  727. if (gl_initialization_error) {
  728. OS::get_singleton()->alert("Your browser does not support any of the supported WebGL versions.\n"
  729. "Please update your browser version.",
  730. "Unable to initialize Video driver");
  731. return ERR_UNAVAILABLE;
  732. }
  733. video_driver_index = p_video_driver;
  734. AudioDriverManager::initialize(p_audio_driver);
  735. visual_server = memnew(VisualServerRaster());
  736. #ifndef NO_THREADS
  737. visual_server = memnew(VisualServerWrapMT(visual_server, false));
  738. #endif
  739. input = memnew(InputDefault);
  740. EMSCRIPTEN_RESULT result;
  741. #define EM_CHECK(ev) \
  742. if (result != EMSCRIPTEN_RESULT_SUCCESS) \
  743. ERR_PRINT("Error while setting " #ev " callback: Code " + itos(result))
  744. #define SET_EM_CALLBACK(target, ev, cb) \
  745. result = emscripten_set_##ev##_callback(target, NULL, true, &cb); \
  746. EM_CHECK(ev)
  747. #define SET_EM_WINDOW_CALLBACK(ev, cb) \
  748. result = emscripten_set_##ev##_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, &cb); \
  749. EM_CHECK(ev)
  750. // These callbacks from Emscripten's html5.h suffice to access most
  751. // JavaScript APIs.
  752. SET_EM_CALLBACK(canvas_id, mousedown, mouse_button_callback)
  753. SET_EM_WINDOW_CALLBACK(mousemove, mousemove_callback)
  754. SET_EM_WINDOW_CALLBACK(mouseup, mouse_button_callback)
  755. SET_EM_CALLBACK(canvas_id, wheel, wheel_callback)
  756. SET_EM_CALLBACK(canvas_id, touchstart, touch_press_callback)
  757. SET_EM_CALLBACK(canvas_id, touchmove, touchmove_callback)
  758. SET_EM_CALLBACK(canvas_id, touchend, touch_press_callback)
  759. SET_EM_CALLBACK(canvas_id, touchcancel, touch_press_callback)
  760. SET_EM_CALLBACK(canvas_id, keydown, keydown_callback)
  761. SET_EM_CALLBACK(canvas_id, keypress, keypress_callback)
  762. SET_EM_CALLBACK(canvas_id, keyup, keyup_callback)
  763. SET_EM_CALLBACK(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, fullscreenchange, fullscreen_change_callback)
  764. #undef SET_EM_CALLBACK
  765. #undef EM_CHECK
  766. // For APIs that are not (sufficiently) exposed, a
  767. // library is used below (implemented in library_godot_display.js).
  768. godot_js_display_notification_cb(&OS_JavaScript::send_notification_callback,
  769. MainLoop::NOTIFICATION_WM_MOUSE_ENTER,
  770. MainLoop::NOTIFICATION_WM_MOUSE_EXIT,
  771. MainLoop::NOTIFICATION_WM_FOCUS_IN,
  772. MainLoop::NOTIFICATION_WM_FOCUS_OUT);
  773. godot_js_display_paste_cb(&OS_JavaScript::update_clipboard_callback);
  774. godot_js_display_drop_files_cb(&OS_JavaScript::drop_files_callback);
  775. godot_js_display_gamepad_cb(&OS_JavaScript::gamepad_callback);
  776. godot_js_display_vk_cb(&input_text_callback);
  777. visual_server->init();
  778. return OK;
  779. }
  780. void OS_JavaScript::input_text_callback(const char *p_text, int p_cursor) {
  781. OS_JavaScript *os = OS_JavaScript::get_singleton();
  782. if (!os || !os->get_main_loop()) {
  783. return;
  784. }
  785. os->get_main_loop()->input_text(String::utf8(p_text));
  786. Ref<InputEventKey> k;
  787. for (int i = 0; i < p_cursor; i++) {
  788. k.instance();
  789. k->set_pressed(true);
  790. k->set_echo(false);
  791. k->set_scancode(KEY_RIGHT);
  792. os->input->parse_input_event(k);
  793. k.instance();
  794. k->set_pressed(false);
  795. k->set_echo(false);
  796. k->set_scancode(KEY_RIGHT);
  797. os->input->parse_input_event(k);
  798. }
  799. }
  800. bool OS_JavaScript::has_virtual_keyboard() const {
  801. return godot_js_display_vk_available() != 0;
  802. }
  803. void OS_JavaScript::show_virtual_keyboard(const String &p_existing_text, const Rect2 &p_screen_rect, bool p_multiline, int p_max_input_length, int p_cursor_start, int p_cursor_end) {
  804. godot_js_display_vk_show(p_existing_text.utf8().get_data(), p_multiline, p_cursor_start, p_cursor_end);
  805. }
  806. void OS_JavaScript::hide_virtual_keyboard() {
  807. godot_js_display_vk_hide();
  808. }
  809. bool OS_JavaScript::get_swap_ok_cancel() {
  810. return swap_ok_cancel;
  811. }
  812. void OS_JavaScript::swap_buffers() {
  813. emscripten_webgl_commit_frame();
  814. }
  815. void OS_JavaScript::set_main_loop(MainLoop *p_main_loop) {
  816. main_loop = p_main_loop;
  817. input->set_main_loop(p_main_loop);
  818. }
  819. MainLoop *OS_JavaScript::get_main_loop() const {
  820. return main_loop;
  821. }
  822. void OS_JavaScript::resume_audio() {
  823. if (audio_driver_javascript) {
  824. audio_driver_javascript->resume();
  825. }
  826. }
  827. void OS_JavaScript::fs_sync_callback() {
  828. get_singleton()->idb_is_syncing = false;
  829. }
  830. bool OS_JavaScript::main_loop_iterate() {
  831. if (is_userfs_persistent() && idb_needs_sync && !idb_is_syncing) {
  832. idb_is_syncing = true;
  833. idb_needs_sync = false;
  834. godot_js_os_fs_sync(&OS_JavaScript::fs_sync_callback);
  835. }
  836. input->flush_buffered_events();
  837. if (godot_js_display_gamepad_sample() == OK)
  838. process_joypads();
  839. if (just_exited_fullscreen) {
  840. if (window_maximized) {
  841. EmscriptenFullscreenStrategy strategy;
  842. strategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
  843. strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
  844. strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
  845. strategy.canvasResizedCallback = NULL;
  846. emscripten_enter_soft_fullscreen(canvas_id, &strategy);
  847. } else {
  848. godot_js_display_size_update();
  849. }
  850. just_exited_fullscreen = false;
  851. }
  852. return Main::iteration();
  853. }
  854. int OS_JavaScript::get_screen_dpi(int p_screen) const {
  855. return godot_js_display_screen_dpi_get();
  856. }
  857. float OS_JavaScript::get_screen_scale(int p_screen) const {
  858. return godot_js_display_pixel_ratio_get();
  859. }
  860. float OS_JavaScript::get_screen_max_scale() const {
  861. return get_screen_scale();
  862. }
  863. void OS_JavaScript::delete_main_loop() {
  864. memdelete(main_loop);
  865. main_loop = NULL;
  866. }
  867. void OS_JavaScript::finalize() {
  868. memdelete(input);
  869. visual_server->finish();
  870. emscripten_webgl_commit_frame();
  871. memdelete(visual_server);
  872. emscripten_webgl_destroy_context(webgl_ctx);
  873. if (audio_driver_javascript) {
  874. memdelete(audio_driver_javascript);
  875. }
  876. }
  877. // Miscellaneous
  878. Error OS_JavaScript::execute(const String &p_path, const List<String> &p_arguments, bool p_blocking, ProcessID *r_child_id, String *r_pipe, int *r_exitcode, bool read_stderr, Mutex *p_pipe_mutex) {
  879. Array args;
  880. for (const List<String>::Element *E = p_arguments.front(); E; E = E->next()) {
  881. args.push_back(E->get());
  882. }
  883. String json_args = JSON::print(args);
  884. int failed = godot_js_os_execute(json_args.utf8().get_data());
  885. ERR_FAIL_COND_V_MSG(failed, ERR_UNAVAILABLE, "OS::execute() must be implemented in Javascript via 'engine.setOnExecute' if required.");
  886. return OK;
  887. }
  888. Error OS_JavaScript::kill(const ProcessID &p_pid) {
  889. ERR_FAIL_V_MSG(ERR_UNAVAILABLE, "OS::kill() is not available on the HTML5 platform.");
  890. }
  891. int OS_JavaScript::get_process_id() const {
  892. ERR_FAIL_V_MSG(0, "OS::get_process_id() is not available on the HTML5 platform.");
  893. }
  894. int OS_JavaScript::get_processor_count() const {
  895. return godot_js_os_hw_concurrency_get();
  896. }
  897. bool OS_JavaScript::_check_internal_feature_support(const String &p_feature) {
  898. if (p_feature == "HTML5" || p_feature == "web") {
  899. return true;
  900. }
  901. #ifdef JAVASCRIPT_EVAL_ENABLED
  902. if (p_feature == "JavaScript") {
  903. return true;
  904. }
  905. #endif
  906. #ifndef NO_THREADS
  907. if (p_feature == "threads") {
  908. return true;
  909. }
  910. #endif
  911. #if WASM_GDNATIVE
  912. if (p_feature == "wasm32") {
  913. return true;
  914. }
  915. #endif
  916. return false;
  917. }
  918. void OS_JavaScript::alert(const String &p_alert, const String &p_title) {
  919. godot_js_display_alert(p_alert.utf8().get_data());
  920. }
  921. void OS_JavaScript::set_window_title(const String &p_title) {
  922. godot_js_display_window_title_set(p_title.utf8().get_data());
  923. }
  924. void OS_JavaScript::set_icon(const Ref<Image> &p_icon) {
  925. ERR_FAIL_COND(p_icon.is_null());
  926. Ref<Image> icon = p_icon;
  927. if (icon->is_compressed()) {
  928. icon = icon->duplicate();
  929. ERR_FAIL_COND(icon->decompress() != OK);
  930. }
  931. if (icon->get_format() != Image::FORMAT_RGBA8) {
  932. if (icon == p_icon)
  933. icon = icon->duplicate();
  934. icon->convert(Image::FORMAT_RGBA8);
  935. }
  936. png_image png_meta;
  937. memset(&png_meta, 0, sizeof png_meta);
  938. png_meta.version = PNG_IMAGE_VERSION;
  939. png_meta.width = icon->get_width();
  940. png_meta.height = icon->get_height();
  941. png_meta.format = PNG_FORMAT_RGBA;
  942. PoolByteArray png;
  943. size_t len;
  944. PoolByteArray::Read r = icon->get_data().read();
  945. ERR_FAIL_COND(!png_image_write_get_memory_size(png_meta, len, 0, r.ptr(), 0, NULL));
  946. png.resize(len);
  947. PoolByteArray::Write w = png.write();
  948. ERR_FAIL_COND(!png_image_write_to_memory(&png_meta, w.ptr(), &len, 0, r.ptr(), 0, NULL));
  949. w = PoolByteArray::Write();
  950. r = png.read();
  951. godot_js_display_window_icon_set(r.ptr(), len);
  952. }
  953. String OS_JavaScript::get_executable_path() const {
  954. return OS::get_executable_path();
  955. }
  956. Error OS_JavaScript::shell_open(String p_uri) {
  957. // Open URI in a new tab, browser will deal with it by protocol.
  958. godot_js_os_shell_open(p_uri.utf8().get_data());
  959. return OK;
  960. }
  961. String OS_JavaScript::get_name() const {
  962. return "HTML5";
  963. }
  964. bool OS_JavaScript::can_draw() const {
  965. return true; // Always?
  966. }
  967. String OS_JavaScript::get_user_data_dir() const {
  968. return "/userfs";
  969. };
  970. String OS_JavaScript::get_cache_path() const {
  971. return "/home/web_user/.cache";
  972. }
  973. String OS_JavaScript::get_config_path() const {
  974. return "/home/web_user/.config";
  975. }
  976. String OS_JavaScript::get_data_path() const {
  977. return "/home/web_user/.local/share";
  978. }
  979. OS::PowerState OS_JavaScript::get_power_state() {
  980. WARN_PRINT_ONCE("Power management is not supported for the HTML5 platform, defaulting to POWERSTATE_UNKNOWN");
  981. return OS::POWERSTATE_UNKNOWN;
  982. }
  983. int OS_JavaScript::get_power_seconds_left() {
  984. WARN_PRINT_ONCE("Power management is not supported for the HTML5 platform, defaulting to -1");
  985. return -1;
  986. }
  987. int OS_JavaScript::get_power_percent_left() {
  988. WARN_PRINT_ONCE("Power management is not supported for the HTML5 platform, defaulting to -1");
  989. return -1;
  990. }
  991. void OS_JavaScript::file_access_close_callback(const String &p_file, int p_flags) {
  992. OS_JavaScript *os = get_singleton();
  993. if (!(os->is_userfs_persistent() && p_flags & FileAccess::WRITE)) {
  994. return; // FS persistence is not working or we are not writing.
  995. }
  996. bool is_file_persistent = p_file.begins_with("/userfs");
  997. #ifdef TOOLS_ENABLED
  998. // Hack for editor persistence (can we track).
  999. is_file_persistent = is_file_persistent || p_file.begins_with("/home/web_user/");
  1000. #endif
  1001. if (is_file_persistent) {
  1002. os->idb_needs_sync = true;
  1003. }
  1004. }
  1005. bool OS_JavaScript::is_userfs_persistent() const {
  1006. return idb_available;
  1007. }
  1008. Error OS_JavaScript::open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path) {
  1009. String path = p_path.get_file();
  1010. p_library_handle = dlopen(path.utf8().get_data(), RTLD_NOW);
  1011. ERR_FAIL_COND_V_MSG(!p_library_handle, ERR_CANT_OPEN, "Can't open dynamic library: " + p_path + ". Error: " + dlerror());
  1012. return OK;
  1013. }
  1014. OS_JavaScript *OS_JavaScript::get_singleton() {
  1015. return static_cast<OS_JavaScript *>(OS::get_singleton());
  1016. }
  1017. OS_JavaScript::OS_JavaScript() {
  1018. // Expose method for requesting quit.
  1019. godot_js_os_request_quit_cb(&request_quit_callback);
  1020. // Set canvas ID
  1021. godot_js_config_canvas_id_get(canvas_id, sizeof(canvas_id));
  1022. cursor_inside_canvas = true;
  1023. cursor_shape = OS::CURSOR_ARROW;
  1024. last_click_button_index = -1;
  1025. last_click_ms = 0;
  1026. last_click_pos = Point2(-100, -100);
  1027. window_maximized = false;
  1028. entering_fullscreen = false;
  1029. just_exited_fullscreen = false;
  1030. transparency_enabled = false;
  1031. main_loop = NULL;
  1032. visual_server = NULL;
  1033. audio_driver_javascript = NULL;
  1034. swap_ok_cancel = false;
  1035. idb_available = godot_js_os_fs_is_persistent() != 0;
  1036. idb_needs_sync = false;
  1037. idb_is_syncing = false;
  1038. if (AudioDriverJavaScript::is_available()) {
  1039. audio_driver_javascript = memnew(AudioDriverJavaScript);
  1040. AudioDriverManager::add_driver(audio_driver_javascript);
  1041. }
  1042. Vector<Logger *> loggers;
  1043. loggers.push_back(memnew(StdLogger));
  1044. _set_logger(memnew(CompositeLogger(loggers)));
  1045. FileAccessUnix::close_notification_func = file_access_close_callback;
  1046. }