os_javascript.cpp 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239
  1. /*************************************************************************/
  2. /* os_javascript.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2019 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/file_access_buffered_fa.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. #include <emscripten.h>
  39. #include <png.h>
  40. #include <stdlib.h>
  41. #include "dom_keys.inc"
  42. #define DOM_BUTTON_LEFT 0
  43. #define DOM_BUTTON_MIDDLE 1
  44. #define DOM_BUTTON_RIGHT 2
  45. #define DOM_BUTTON_XBUTTON1 3
  46. #define DOM_BUTTON_XBUTTON2 4
  47. // Window (canvas)
  48. static void focus_canvas() {
  49. /* clang-format off */
  50. EM_ASM(
  51. Module.canvas.focus();
  52. );
  53. /* clang-format on */
  54. }
  55. static bool is_canvas_focused() {
  56. /* clang-format off */
  57. return EM_ASM_INT_V(
  58. return document.activeElement == Module.canvas;
  59. );
  60. /* clang-format on */
  61. }
  62. static bool cursor_inside_canvas = true;
  63. EM_BOOL OS_JavaScript::fullscreen_change_callback(int p_event_type, const EmscriptenFullscreenChangeEvent *p_event, void *p_user_data) {
  64. OS_JavaScript *os = get_singleton();
  65. // Empty ID is canvas.
  66. String target_id = String::utf8(p_event->id);
  67. if (target_id.empty() || target_id == "canvas") {
  68. // This event property is the only reliable data on
  69. // browser fullscreen state.
  70. os->video_mode.fullscreen = p_event->isFullscreen;
  71. if (os->video_mode.fullscreen) {
  72. os->entering_fullscreen = false;
  73. } else {
  74. // Restoring maximized window now will cause issues,
  75. // so delay until main_loop_iterate.
  76. os->just_exited_fullscreen = true;
  77. }
  78. }
  79. return false;
  80. }
  81. void OS_JavaScript::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
  82. video_mode = p_video_mode;
  83. }
  84. OS::VideoMode OS_JavaScript::get_video_mode(int p_screen) const {
  85. return video_mode;
  86. }
  87. Size2 OS_JavaScript::get_screen_size(int p_screen) const {
  88. EmscriptenFullscreenChangeEvent ev;
  89. EMSCRIPTEN_RESULT result = emscripten_get_fullscreen_status(&ev);
  90. ERR_FAIL_COND_V(result != EMSCRIPTEN_RESULT_SUCCESS, Size2());
  91. return Size2(ev.screenWidth, ev.screenHeight);
  92. }
  93. void OS_JavaScript::set_window_size(const Size2 p_size) {
  94. windowed_size = p_size;
  95. if (video_mode.fullscreen) {
  96. window_maximized = false;
  97. set_window_fullscreen(false);
  98. } else {
  99. if (window_maximized) {
  100. emscripten_exit_soft_fullscreen();
  101. window_maximized = false;
  102. }
  103. emscripten_set_canvas_element_size(NULL, p_size.x, p_size.y);
  104. }
  105. }
  106. Size2 OS_JavaScript::get_window_size() const {
  107. int canvas[2];
  108. emscripten_get_canvas_element_size(NULL, canvas, canvas + 1);
  109. return Size2(canvas[0], canvas[1]);
  110. }
  111. void OS_JavaScript::set_window_maximized(bool p_enabled) {
  112. if (video_mode.fullscreen) {
  113. window_maximized = p_enabled;
  114. set_window_fullscreen(false);
  115. } else if (!p_enabled) {
  116. emscripten_exit_soft_fullscreen();
  117. window_maximized = false;
  118. } else if (!window_maximized) {
  119. // Prevent calling emscripten_enter_soft_fullscreen mutltiple times,
  120. // this would hide page elements permanently.
  121. EmscriptenFullscreenStrategy strategy;
  122. strategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
  123. strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
  124. strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
  125. strategy.canvasResizedCallback = NULL;
  126. emscripten_enter_soft_fullscreen(NULL, &strategy);
  127. window_maximized = p_enabled;
  128. }
  129. }
  130. bool OS_JavaScript::is_window_maximized() const {
  131. return window_maximized;
  132. }
  133. void OS_JavaScript::set_window_fullscreen(bool p_enabled) {
  134. if (p_enabled == video_mode.fullscreen) {
  135. return;
  136. }
  137. // Just request changes here, if successful, logic continues in
  138. // fullscreen_change_callback.
  139. if (p_enabled) {
  140. if (window_maximized) {
  141. // Soft fullsreen during real fullscreen can cause issues, so exit.
  142. // This must be called before requesting full screen.
  143. emscripten_exit_soft_fullscreen();
  144. }
  145. EmscriptenFullscreenStrategy strategy;
  146. strategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
  147. strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
  148. strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
  149. strategy.canvasResizedCallback = NULL;
  150. EMSCRIPTEN_RESULT result = emscripten_request_fullscreen_strategy(NULL, false, &strategy);
  151. ERR_EXPLAIN("Enabling fullscreen is only possible from an input callback for the HTML5 platform");
  152. ERR_FAIL_COND(result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED);
  153. ERR_FAIL_COND(result != EMSCRIPTEN_RESULT_SUCCESS);
  154. // Not fullscreen yet, so prevent "windowed" canvas dimensions from
  155. // being overwritten.
  156. entering_fullscreen = true;
  157. } else {
  158. // No logic allowed here, since exiting w/ ESC key won't use this function.
  159. ERR_FAIL_COND(emscripten_exit_fullscreen() != EMSCRIPTEN_RESULT_SUCCESS);
  160. }
  161. }
  162. bool OS_JavaScript::is_window_fullscreen() const {
  163. return video_mode.fullscreen;
  164. }
  165. void OS_JavaScript::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
  166. Size2 screen = get_screen_size();
  167. p_list->push_back(OS::VideoMode(screen.width, screen.height, true));
  168. }
  169. // Keys
  170. template <typename T>
  171. static void dom2godot_mod(T *emscripten_event_ptr, Ref<InputEventWithModifiers> godot_event) {
  172. godot_event->set_shift(emscripten_event_ptr->shiftKey);
  173. godot_event->set_alt(emscripten_event_ptr->altKey);
  174. godot_event->set_control(emscripten_event_ptr->ctrlKey);
  175. godot_event->set_metakey(emscripten_event_ptr->metaKey);
  176. }
  177. static Ref<InputEventKey> setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) {
  178. Ref<InputEventKey> ev;
  179. ev.instance();
  180. ev->set_echo(emscripten_event->repeat);
  181. dom2godot_mod(emscripten_event, ev);
  182. ev->set_scancode(dom2godot_scancode(emscripten_event->keyCode));
  183. String unicode = String::utf8(emscripten_event->key);
  184. // Check if empty or multi-character (e.g. `CapsLock`).
  185. if (unicode.length() != 1) {
  186. // Might be empty as well, but better than nonsense.
  187. unicode = String::utf8(emscripten_event->charValue);
  188. }
  189. if (unicode.length() == 1) {
  190. ev->set_unicode(unicode[0]);
  191. }
  192. return ev;
  193. }
  194. EM_BOOL OS_JavaScript::keydown_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  195. OS_JavaScript *os = get_singleton();
  196. Ref<InputEventKey> ev = setup_key_event(p_event);
  197. ev->set_pressed(true);
  198. if (ev->get_unicode() == 0 && keycode_has_unicode(ev->get_scancode())) {
  199. // Defer to keypress event for legacy unicode retrieval.
  200. os->deferred_key_event = ev;
  201. // Do not suppress keypress event.
  202. return false;
  203. }
  204. os->input->parse_input_event(ev);
  205. return true;
  206. }
  207. EM_BOOL OS_JavaScript::keypress_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  208. OS_JavaScript *os = get_singleton();
  209. os->deferred_key_event->set_unicode(p_event->charCode);
  210. os->input->parse_input_event(os->deferred_key_event);
  211. return true;
  212. }
  213. EM_BOOL OS_JavaScript::keyup_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data) {
  214. Ref<InputEventKey> ev = setup_key_event(p_event);
  215. ev->set_pressed(false);
  216. get_singleton()->input->parse_input_event(ev);
  217. return ev->get_scancode() != KEY_UNKNOWN && ev->get_scancode() != 0;
  218. }
  219. // Mouse
  220. Point2 OS_JavaScript::get_mouse_position() const {
  221. return input->get_mouse_position();
  222. }
  223. int OS_JavaScript::get_mouse_button_state() const {
  224. return input->get_mouse_button_mask();
  225. }
  226. EM_BOOL OS_JavaScript::mouse_button_callback(int p_event_type, const EmscriptenMouseEvent *p_event, void *p_user_data) {
  227. OS_JavaScript *os = get_singleton();
  228. Ref<InputEventMouseButton> ev;
  229. ev.instance();
  230. ev->set_pressed(p_event_type == EMSCRIPTEN_EVENT_MOUSEDOWN);
  231. ev->set_position(Point2(p_event->canvasX, p_event->canvasY));
  232. ev->set_global_position(ev->get_position());
  233. dom2godot_mod(p_event, ev);
  234. switch (p_event->button) {
  235. case DOM_BUTTON_LEFT: ev->set_button_index(BUTTON_LEFT); break;
  236. case DOM_BUTTON_MIDDLE: ev->set_button_index(BUTTON_MIDDLE); break;
  237. case DOM_BUTTON_RIGHT: ev->set_button_index(BUTTON_RIGHT); break;
  238. case DOM_BUTTON_XBUTTON1: ev->set_button_index(BUTTON_XBUTTON1); break;
  239. case DOM_BUTTON_XBUTTON2: ev->set_button_index(BUTTON_XBUTTON2); break;
  240. default: return false;
  241. }
  242. if (ev->is_pressed()) {
  243. uint64_t diff = p_event->timestamp - os->last_click_ms;
  244. if (ev->get_button_index() == os->last_click_button_index) {
  245. if (diff < 400 && Point2(os->last_click_pos).distance_to(ev->get_position()) < 5) {
  246. os->last_click_ms = 0;
  247. os->last_click_pos = Point2(-100, -100);
  248. os->last_click_button_index = -1;
  249. ev->set_doubleclick(true);
  250. }
  251. } else {
  252. os->last_click_button_index = ev->get_button_index();
  253. }
  254. if (!ev->is_doubleclick()) {
  255. os->last_click_ms += diff;
  256. os->last_click_pos = ev->get_position();
  257. }
  258. }
  259. int mask = os->input->get_mouse_button_mask();
  260. int button_flag = 1 << (ev->get_button_index() - 1);
  261. if (ev->is_pressed()) {
  262. // Since the event is consumed, focus manually. The containing iframe,
  263. // if exists, may not have focus yet, so focus even if already focused.
  264. focus_canvas();
  265. mask |= button_flag;
  266. } else if (mask & button_flag) {
  267. mask &= ~button_flag;
  268. } else {
  269. // Received release event, but press was outside the canvas, so ignore.
  270. return false;
  271. }
  272. ev->set_button_mask(mask);
  273. os->input->parse_input_event(ev);
  274. // Prevent multi-click text selection and wheel-click scrolling anchor.
  275. // Context menu is prevented through contextmenu event.
  276. return true;
  277. }
  278. EM_BOOL OS_JavaScript::mousemove_callback(int p_event_type, const EmscriptenMouseEvent *p_event, void *p_user_data) {
  279. OS_JavaScript *os = get_singleton();
  280. int input_mask = os->input->get_mouse_button_mask();
  281. Point2 pos = Point2(p_event->canvasX, p_event->canvasY);
  282. // For motion outside the canvas, only read mouse movement if dragging
  283. // started inside the canvas; imitating desktop app behaviour.
  284. if (!cursor_inside_canvas && !input_mask)
  285. return false;
  286. Ref<InputEventMouseMotion> ev;
  287. ev.instance();
  288. dom2godot_mod(p_event, ev);
  289. ev->set_button_mask(input_mask);
  290. ev->set_position(pos);
  291. ev->set_global_position(ev->get_position());
  292. ev->set_relative(Vector2(p_event->movementX, p_event->movementY));
  293. os->input->set_mouse_position(ev->get_position());
  294. ev->set_speed(os->input->get_last_mouse_speed());
  295. os->input->parse_input_event(ev);
  296. // Don't suppress mouseover/-leave events.
  297. return false;
  298. }
  299. static const char *godot2dom_cursor(OS::CursorShape p_shape) {
  300. switch (p_shape) {
  301. case OS::CURSOR_ARROW:
  302. default:
  303. return "auto";
  304. case OS::CURSOR_IBEAM: return "text";
  305. case OS::CURSOR_POINTING_HAND: return "pointer";
  306. case OS::CURSOR_CROSS: return "crosshair";
  307. case OS::CURSOR_WAIT: return "progress";
  308. case OS::CURSOR_BUSY: return "wait";
  309. case OS::CURSOR_DRAG: return "grab";
  310. case OS::CURSOR_CAN_DROP: return "grabbing";
  311. case OS::CURSOR_FORBIDDEN: return "no-drop";
  312. case OS::CURSOR_VSIZE: return "ns-resize";
  313. case OS::CURSOR_HSIZE: return "ew-resize";
  314. case OS::CURSOR_BDIAGSIZE: return "nesw-resize";
  315. case OS::CURSOR_FDIAGSIZE: return "nwse-resize";
  316. case OS::CURSOR_MOVE: return "move";
  317. case OS::CURSOR_VSPLIT: return "row-resize";
  318. case OS::CURSOR_HSPLIT: return "col-resize";
  319. case OS::CURSOR_HELP: return "help";
  320. }
  321. }
  322. static void set_css_cursor(const char *p_cursor) {
  323. /* clang-format off */
  324. EM_ASM_({
  325. Module.canvas.style.cursor = UTF8ToString($0);
  326. }, p_cursor);
  327. /* clang-format on */
  328. }
  329. static bool is_css_cursor_hidden() {
  330. /* clang-format off */
  331. return EM_ASM_INT({
  332. return Module.canvas.style.cursor === 'none';
  333. });
  334. /* clang-format on */
  335. }
  336. void OS_JavaScript::set_cursor_shape(CursorShape p_shape) {
  337. ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
  338. if (get_mouse_mode() == MOUSE_MODE_VISIBLE) {
  339. if (cursors[p_shape] != "") {
  340. Vector<String> url = cursors[p_shape].split("?");
  341. set_css_cursor(("url(\"" + url[0] + "\") " + url[1] + ", auto").utf8());
  342. } else {
  343. set_css_cursor(godot2dom_cursor(p_shape));
  344. }
  345. }
  346. cursor_shape = p_shape;
  347. }
  348. void OS_JavaScript::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
  349. if (p_cursor.is_valid()) {
  350. Ref<Texture> texture = p_cursor;
  351. Ref<AtlasTexture> atlas_texture = p_cursor;
  352. Ref<Image> image;
  353. Size2 texture_size;
  354. Rect2 atlas_rect;
  355. if (texture.is_valid()) {
  356. image = texture->get_data();
  357. }
  358. if (!image.is_valid() && atlas_texture.is_valid()) {
  359. texture = atlas_texture->get_atlas();
  360. atlas_rect.size.width = texture->get_width();
  361. atlas_rect.size.height = texture->get_height();
  362. atlas_rect.position.x = atlas_texture->get_region().position.x;
  363. atlas_rect.position.y = atlas_texture->get_region().position.y;
  364. texture_size.width = atlas_texture->get_region().size.x;
  365. texture_size.height = atlas_texture->get_region().size.y;
  366. } else if (image.is_valid()) {
  367. texture_size.width = texture->get_width();
  368. texture_size.height = texture->get_height();
  369. }
  370. ERR_FAIL_COND(!texture.is_valid());
  371. ERR_FAIL_COND(p_hotspot.x < 0 || p_hotspot.y < 0);
  372. ERR_FAIL_COND(texture_size.width > 256 || texture_size.height > 256);
  373. ERR_FAIL_COND(p_hotspot.x > texture_size.width || p_hotspot.y > texture_size.height);
  374. image = texture->get_data();
  375. ERR_FAIL_COND(!image.is_valid());
  376. if (atlas_texture.is_valid())
  377. image->crop_from_point(
  378. atlas_rect.position.x,
  379. atlas_rect.position.y,
  380. texture_size.width,
  381. texture_size.height);
  382. if (image->get_format() != Image::FORMAT_RGBA8) {
  383. image->convert(Image::FORMAT_RGBA8);
  384. }
  385. png_image png_meta;
  386. memset(&png_meta, 0, sizeof png_meta);
  387. png_meta.version = PNG_IMAGE_VERSION;
  388. png_meta.width = texture_size.width;
  389. png_meta.height = texture_size.height;
  390. png_meta.format = PNG_FORMAT_RGBA;
  391. PoolByteArray png;
  392. size_t len;
  393. PoolByteArray::Read r = image->get_data().read();
  394. ERR_FAIL_COND(!png_image_write_get_memory_size(png_meta, len, 0, r.ptr(), 0, NULL));
  395. png.resize(len);
  396. PoolByteArray::Write w = png.write();
  397. ERR_FAIL_COND(!png_image_write_to_memory(&png_meta, w.ptr(), &len, 0, r.ptr(), 0, NULL));
  398. w = PoolByteArray::Write();
  399. r = png.read();
  400. char *object_url;
  401. /* clang-format off */
  402. EM_ASM({
  403. var PNG_PTR = $0;
  404. var PNG_LEN = $1;
  405. var PTR = $2;
  406. var png = new Blob([HEAPU8.slice(PNG_PTR, PNG_PTR + PNG_LEN)], { type: 'image/png' });
  407. var url = URL.createObjectURL(png);
  408. var length_bytes = lengthBytesUTF8(url) + 1;
  409. var string_on_wasm_heap = _malloc(length_bytes);
  410. setValue(PTR, string_on_wasm_heap, '*');
  411. stringToUTF8(url, string_on_wasm_heap, length_bytes);
  412. }, r.ptr(), len, &object_url);
  413. /* clang-format on */
  414. r = PoolByteArray::Read();
  415. String url = String::utf8(object_url) + "?" + itos(p_hotspot.x) + " " + itos(p_hotspot.y);
  416. /* clang-format off */
  417. EM_ASM({ _free($0); }, object_url);
  418. /* clang-format on */
  419. if (cursors[p_shape] != "") {
  420. /* clang-format off */
  421. EM_ASM({
  422. URL.revokeObjectURL(UTF8ToString($0).split('?')[0]);
  423. }, cursors[p_shape].utf8().get_data());
  424. /* clang-format on */
  425. cursors[p_shape] = "";
  426. }
  427. cursors[p_shape] = url;
  428. } else if (cursors[p_shape] != "") {
  429. /* clang-format off */
  430. EM_ASM({
  431. URL.revokeObjectURL(UTF8ToString($0).split('?')[0]);
  432. }, cursors[p_shape].utf8().get_data());
  433. /* clang-format on */
  434. cursors[p_shape] = "";
  435. }
  436. set_cursor_shape(cursor_shape);
  437. }
  438. void OS_JavaScript::set_mouse_mode(OS::MouseMode p_mode) {
  439. ERR_EXPLAIN("MOUSE_MODE_CONFINED is not supported for the HTML5 platform");
  440. ERR_FAIL_COND(p_mode == MOUSE_MODE_CONFINED);
  441. if (p_mode == get_mouse_mode())
  442. return;
  443. if (p_mode == MOUSE_MODE_VISIBLE) {
  444. // set_css_cursor must be called before set_cursor_shape to make the cursor visible
  445. set_css_cursor(godot2dom_cursor(cursor_shape));
  446. set_cursor_shape(cursor_shape);
  447. emscripten_exit_pointerlock();
  448. } else if (p_mode == MOUSE_MODE_HIDDEN) {
  449. set_css_cursor("none");
  450. emscripten_exit_pointerlock();
  451. } else if (p_mode == MOUSE_MODE_CAPTURED) {
  452. EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("canvas", false);
  453. ERR_EXPLAIN("MOUSE_MODE_CAPTURED can only be entered from within an appropriate input callback");
  454. ERR_FAIL_COND(result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED);
  455. ERR_FAIL_COND(result != EMSCRIPTEN_RESULT_SUCCESS);
  456. // set_css_cursor must be called before set_cursor_shape to make the cursor visible
  457. set_css_cursor(godot2dom_cursor(cursor_shape));
  458. set_cursor_shape(cursor_shape);
  459. }
  460. }
  461. OS::MouseMode OS_JavaScript::get_mouse_mode() const {
  462. if (is_css_cursor_hidden())
  463. return MOUSE_MODE_HIDDEN;
  464. EmscriptenPointerlockChangeEvent ev;
  465. emscripten_get_pointerlock_status(&ev);
  466. return (ev.isActive && String::utf8(ev.id) == "canvas") ? MOUSE_MODE_CAPTURED : MOUSE_MODE_VISIBLE;
  467. }
  468. // Wheel
  469. EM_BOOL OS_JavaScript::wheel_callback(int p_event_type, const EmscriptenWheelEvent *p_event, void *p_user_data) {
  470. ERR_FAIL_COND_V(p_event_type != EMSCRIPTEN_EVENT_WHEEL, false);
  471. if (!is_canvas_focused()) {
  472. if (cursor_inside_canvas) {
  473. focus_canvas();
  474. } else {
  475. return false;
  476. }
  477. }
  478. InputDefault *input = get_singleton()->input;
  479. Ref<InputEventMouseButton> ev;
  480. ev.instance();
  481. ev->set_position(input->get_mouse_position());
  482. ev->set_global_position(ev->get_position());
  483. ev->set_shift(input->is_key_pressed(KEY_SHIFT));
  484. ev->set_alt(input->is_key_pressed(KEY_ALT));
  485. ev->set_control(input->is_key_pressed(KEY_CONTROL));
  486. ev->set_metakey(input->is_key_pressed(KEY_META));
  487. if (p_event->deltaY < 0)
  488. ev->set_button_index(BUTTON_WHEEL_UP);
  489. else if (p_event->deltaY > 0)
  490. ev->set_button_index(BUTTON_WHEEL_DOWN);
  491. else if (p_event->deltaX > 0)
  492. ev->set_button_index(BUTTON_WHEEL_LEFT);
  493. else if (p_event->deltaX < 0)
  494. ev->set_button_index(BUTTON_WHEEL_RIGHT);
  495. else
  496. return false;
  497. // Different browsers give wildly different delta values, and we can't
  498. // interpret deltaMode, so use default value for wheel events' factor.
  499. int button_flag = 1 << (ev->get_button_index() - 1);
  500. ev->set_pressed(true);
  501. ev->set_button_mask(input->get_mouse_button_mask() | button_flag);
  502. input->parse_input_event(ev);
  503. ev->set_pressed(false);
  504. ev->set_button_mask(input->get_mouse_button_mask() & ~button_flag);
  505. input->parse_input_event(ev);
  506. return true;
  507. }
  508. // Touch
  509. bool OS_JavaScript::has_touchscreen_ui_hint() const {
  510. /* clang-format off */
  511. return EM_ASM_INT_V(
  512. return 'ontouchstart' in window;
  513. );
  514. /* clang-format on */
  515. }
  516. EM_BOOL OS_JavaScript::touch_press_callback(int p_event_type, const EmscriptenTouchEvent *p_event, void *p_user_data) {
  517. OS_JavaScript *os = get_singleton();
  518. Ref<InputEventScreenTouch> ev;
  519. ev.instance();
  520. int lowest_id_index = -1;
  521. for (int i = 0; i < p_event->numTouches; ++i) {
  522. const EmscriptenTouchPoint &touch = p_event->touches[i];
  523. if (lowest_id_index == -1 || touch.identifier < p_event->touches[lowest_id_index].identifier)
  524. lowest_id_index = i;
  525. if (!touch.isChanged)
  526. continue;
  527. ev->set_index(touch.identifier);
  528. ev->set_position(Point2(touch.canvasX, touch.canvasY));
  529. os->touches[i] = ev->get_position();
  530. ev->set_pressed(p_event_type == EMSCRIPTEN_EVENT_TOUCHSTART);
  531. os->input->parse_input_event(ev);
  532. }
  533. return true;
  534. }
  535. EM_BOOL OS_JavaScript::touchmove_callback(int p_event_type, const EmscriptenTouchEvent *p_event, void *p_user_data) {
  536. OS_JavaScript *os = get_singleton();
  537. Ref<InputEventScreenDrag> ev;
  538. ev.instance();
  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->set_index(touch.identifier);
  547. ev->set_position(Point2(touch.canvasX, touch.canvasY));
  548. Point2 &prev = os->touches[i];
  549. ev->set_relative(ev->get_position() - prev);
  550. prev = ev->get_position();
  551. os->input->parse_input_event(ev);
  552. }
  553. return true;
  554. }
  555. // Gamepad
  556. EM_BOOL OS_JavaScript::gamepad_change_callback(int p_event_type, const EmscriptenGamepadEvent *p_event, void *p_user_data) {
  557. InputDefault *input = get_singleton()->input;
  558. if (p_event_type == EMSCRIPTEN_EVENT_GAMEPADCONNECTED) {
  559. String guid = "";
  560. if (String::utf8(p_event->mapping) == "standard")
  561. guid = "Default HTML5 Gamepad";
  562. input->joy_connection_changed(p_event->index, true, String::utf8(p_event->id), guid);
  563. } else {
  564. input->joy_connection_changed(p_event->index, false, "");
  565. }
  566. return true;
  567. }
  568. void OS_JavaScript::process_joypads() {
  569. int joypad_count = emscripten_get_num_gamepads();
  570. for (int joypad = 0; joypad < joypad_count; joypad++) {
  571. EmscriptenGamepadEvent state;
  572. EMSCRIPTEN_RESULT query_result = emscripten_get_gamepad_status(joypad, &state);
  573. // Chromium reserves gamepads slots, so NO_DATA is an expected result.
  574. ERR_CONTINUE(query_result != EMSCRIPTEN_RESULT_SUCCESS &&
  575. query_result != EMSCRIPTEN_RESULT_NO_DATA);
  576. if (query_result == EMSCRIPTEN_RESULT_SUCCESS && state.connected) {
  577. int button_count = MIN(state.numButtons, 18);
  578. int axis_count = MIN(state.numAxes, 8);
  579. for (int button = 0; button < button_count; button++) {
  580. float value = state.analogButton[button];
  581. if (String::utf8(state.mapping) == "standard" && (button == JOY_ANALOG_L2 || button == JOY_ANALOG_R2)) {
  582. InputDefault::JoyAxis joy_axis;
  583. joy_axis.min = 0;
  584. joy_axis.value = value;
  585. input->joy_axis(joypad, button, joy_axis);
  586. } else {
  587. input->joy_button(joypad, button, value);
  588. }
  589. }
  590. for (int axis = 0; axis < axis_count; axis++) {
  591. InputDefault::JoyAxis joy_axis;
  592. joy_axis.min = -1;
  593. joy_axis.value = state.axis[axis];
  594. input->joy_axis(joypad, axis, joy_axis);
  595. }
  596. }
  597. }
  598. }
  599. bool OS_JavaScript::is_joy_known(int p_device) {
  600. return input->is_joy_mapped(p_device);
  601. }
  602. String OS_JavaScript::get_joy_guid(int p_device) const {
  603. return input->get_joy_guid_remapped(p_device);
  604. }
  605. // Video
  606. int OS_JavaScript::get_video_driver_count() const {
  607. return VIDEO_DRIVER_MAX;
  608. }
  609. const char *OS_JavaScript::get_video_driver_name(int p_driver) const {
  610. switch (p_driver) {
  611. case VIDEO_DRIVER_GLES3:
  612. return "GLES3";
  613. case VIDEO_DRIVER_GLES2:
  614. return "GLES2";
  615. }
  616. ERR_EXPLAIN("Invalid video driver index " + itos(p_driver));
  617. ERR_FAIL_V(NULL);
  618. }
  619. // Audio
  620. int OS_JavaScript::get_audio_driver_count() const {
  621. return 1;
  622. }
  623. const char *OS_JavaScript::get_audio_driver_name(int p_driver) const {
  624. return "JavaScript";
  625. }
  626. // Lifecycle
  627. int OS_JavaScript::get_current_video_driver() const {
  628. return video_driver_index;
  629. }
  630. void OS_JavaScript::initialize_core() {
  631. OS_Unix::initialize_core();
  632. FileAccess::make_default<FileAccessBufferedFA<FileAccessUnix> >(FileAccess::ACCESS_RESOURCES);
  633. }
  634. Error OS_JavaScript::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
  635. EmscriptenWebGLContextAttributes attributes;
  636. emscripten_webgl_init_context_attributes(&attributes);
  637. attributes.alpha = false;
  638. attributes.antialias = false;
  639. ERR_FAIL_INDEX_V(p_video_driver, VIDEO_DRIVER_MAX, ERR_INVALID_PARAMETER);
  640. bool gles3 = true;
  641. if (p_video_driver == VIDEO_DRIVER_GLES2) {
  642. gles3 = false;
  643. }
  644. bool gl_initialization_error = false;
  645. while (true) {
  646. if (gles3) {
  647. if (RasterizerGLES3::is_viable() == OK) {
  648. attributes.majorVersion = 2;
  649. RasterizerGLES3::register_config();
  650. RasterizerGLES3::make_current();
  651. break;
  652. } else {
  653. if (GLOBAL_GET("rendering/quality/driver/driver_fallback") == "Best") {
  654. p_video_driver = VIDEO_DRIVER_GLES2;
  655. gles3 = false;
  656. continue;
  657. } else {
  658. gl_initialization_error = true;
  659. break;
  660. }
  661. }
  662. } else {
  663. if (RasterizerGLES2::is_viable() == OK) {
  664. attributes.majorVersion = 1;
  665. RasterizerGLES2::register_config();
  666. RasterizerGLES2::make_current();
  667. break;
  668. } else {
  669. gl_initialization_error = true;
  670. break;
  671. }
  672. }
  673. }
  674. EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(NULL, &attributes);
  675. if (emscripten_webgl_make_context_current(ctx) != EMSCRIPTEN_RESULT_SUCCESS) {
  676. gl_initialization_error = true;
  677. }
  678. if (gl_initialization_error) {
  679. OS::get_singleton()->alert("Your browser does not support any of the supported WebGL versions.\n"
  680. "Please update your browser version.",
  681. "Unable to initialize Video driver");
  682. return ERR_UNAVAILABLE;
  683. }
  684. video_driver_index = p_video_driver;
  685. video_mode = p_desired;
  686. // Can't fulfill fullscreen request during start-up due to browser security.
  687. video_mode.fullscreen = false;
  688. /* clang-format off */
  689. if (EM_ASM_INT_V({ return Module.resizeCanvasOnStart })) {
  690. /* clang-format on */
  691. set_window_size(Size2(video_mode.width, video_mode.height));
  692. } else {
  693. set_window_size(get_window_size());
  694. }
  695. char locale_ptr[16];
  696. /* clang-format off */
  697. EM_ASM_ARGS({
  698. stringToUTF8(Module.locale, $0, 16);
  699. }, locale_ptr);
  700. /* clang-format on */
  701. setenv("LANG", locale_ptr, true);
  702. AudioDriverManager::initialize(p_audio_driver);
  703. VisualServer *visual_server = memnew(VisualServerRaster());
  704. input = memnew(InputDefault);
  705. EMSCRIPTEN_RESULT result;
  706. #define EM_CHECK(ev) \
  707. if (result != EMSCRIPTEN_RESULT_SUCCESS) \
  708. ERR_PRINTS("Error while setting " #ev " callback: Code " + itos(result))
  709. #define SET_EM_CALLBACK(target, ev, cb) \
  710. result = emscripten_set_##ev##_callback(target, NULL, true, &cb); \
  711. EM_CHECK(ev)
  712. #define SET_EM_CALLBACK_NOTARGET(ev, cb) \
  713. result = emscripten_set_##ev##_callback(NULL, true, &cb); \
  714. EM_CHECK(ev)
  715. // These callbacks from Emscripten's html5.h suffice to access most
  716. // JavaScript APIs. For APIs that are not (sufficiently) exposed, EM_ASM
  717. // is used below.
  718. SET_EM_CALLBACK("#window", mousemove, mousemove_callback)
  719. SET_EM_CALLBACK("#canvas", mousedown, mouse_button_callback)
  720. SET_EM_CALLBACK("#window", mouseup, mouse_button_callback)
  721. SET_EM_CALLBACK("#window", wheel, wheel_callback)
  722. SET_EM_CALLBACK("#window", touchstart, touch_press_callback)
  723. SET_EM_CALLBACK("#window", touchmove, touchmove_callback)
  724. SET_EM_CALLBACK("#window", touchend, touch_press_callback)
  725. SET_EM_CALLBACK("#window", touchcancel, touch_press_callback)
  726. SET_EM_CALLBACK("#canvas", keydown, keydown_callback)
  727. SET_EM_CALLBACK("#canvas", keypress, keypress_callback)
  728. SET_EM_CALLBACK("#canvas", keyup, keyup_callback)
  729. SET_EM_CALLBACK(NULL, fullscreenchange, fullscreen_change_callback)
  730. SET_EM_CALLBACK_NOTARGET(gamepadconnected, gamepad_change_callback)
  731. SET_EM_CALLBACK_NOTARGET(gamepaddisconnected, gamepad_change_callback)
  732. #undef SET_EM_CALLBACK_NODATA
  733. #undef SET_EM_CALLBACK
  734. #undef EM_CHECK
  735. /* clang-format off */
  736. EM_ASM_ARGS({
  737. const send_notification = cwrap('send_notification', null, ['number']);
  738. const notifications = arguments;
  739. (['mouseover', 'mouseleave', 'focus', 'blur']).forEach(function(event, index) {
  740. Module.canvas.addEventListener(event, send_notification.bind(null, notifications[index]));
  741. });
  742. },
  743. MainLoop::NOTIFICATION_WM_MOUSE_ENTER,
  744. MainLoop::NOTIFICATION_WM_MOUSE_EXIT,
  745. MainLoop::NOTIFICATION_WM_FOCUS_IN,
  746. MainLoop::NOTIFICATION_WM_FOCUS_OUT
  747. );
  748. /* clang-format on */
  749. visual_server->init();
  750. return OK;
  751. }
  752. void OS_JavaScript::set_main_loop(MainLoop *p_main_loop) {
  753. main_loop = p_main_loop;
  754. input->set_main_loop(p_main_loop);
  755. }
  756. MainLoop *OS_JavaScript::get_main_loop() const {
  757. return main_loop;
  758. }
  759. void OS_JavaScript::run_async() {
  760. main_loop->init();
  761. emscripten_set_main_loop(main_loop_callback, -1, false);
  762. }
  763. void OS_JavaScript::main_loop_callback() {
  764. get_singleton()->main_loop_iterate();
  765. }
  766. bool OS_JavaScript::main_loop_iterate() {
  767. if (is_userfs_persistent() && sync_wait_time >= 0) {
  768. int64_t current_time = get_ticks_msec();
  769. int64_t elapsed_time = current_time - last_sync_check_time;
  770. last_sync_check_time = current_time;
  771. sync_wait_time -= elapsed_time;
  772. if (sync_wait_time < 0) {
  773. /* clang-format off */
  774. EM_ASM(
  775. FS.syncfs(function(err) {
  776. if (err) { console.warn('Failed to save IDB file system: ' + err.message); }
  777. });
  778. );
  779. /* clang-format on */
  780. }
  781. }
  782. process_joypads();
  783. if (just_exited_fullscreen) {
  784. if (window_maximized) {
  785. EmscriptenFullscreenStrategy strategy;
  786. strategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;
  787. strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
  788. strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
  789. strategy.canvasResizedCallback = NULL;
  790. emscripten_enter_soft_fullscreen(NULL, &strategy);
  791. } else {
  792. emscripten_set_canvas_element_size(NULL, windowed_size.width, windowed_size.height);
  793. }
  794. just_exited_fullscreen = false;
  795. }
  796. int canvas[2];
  797. emscripten_get_canvas_element_size(NULL, canvas, canvas + 1);
  798. video_mode.width = canvas[0];
  799. video_mode.height = canvas[1];
  800. if (!window_maximized && !video_mode.fullscreen && !just_exited_fullscreen && !entering_fullscreen) {
  801. windowed_size.width = canvas[0];
  802. windowed_size.height = canvas[1];
  803. }
  804. return Main::iteration();
  805. }
  806. void OS_JavaScript::delete_main_loop() {
  807. memdelete(main_loop);
  808. }
  809. void OS_JavaScript::finalize() {
  810. memdelete(input);
  811. }
  812. // Miscellaneous
  813. 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) {
  814. ERR_EXPLAIN("OS::execute() is not available on the HTML5 platform");
  815. ERR_FAIL_V(ERR_UNAVAILABLE);
  816. }
  817. Error OS_JavaScript::kill(const ProcessID &p_pid) {
  818. ERR_EXPLAIN("OS::kill() is not available on the HTML5 platform");
  819. ERR_FAIL_V(ERR_UNAVAILABLE);
  820. }
  821. int OS_JavaScript::get_process_id() const {
  822. ERR_EXPLAIN("OS::get_process_id() is not available on the HTML5 platform");
  823. ERR_FAIL_V(0);
  824. }
  825. extern "C" EMSCRIPTEN_KEEPALIVE void send_notification(int p_notification) {
  826. if (p_notification == MainLoop::NOTIFICATION_WM_MOUSE_ENTER || p_notification == MainLoop::NOTIFICATION_WM_MOUSE_EXIT) {
  827. cursor_inside_canvas = p_notification == MainLoop::NOTIFICATION_WM_MOUSE_ENTER;
  828. }
  829. OS_JavaScript::get_singleton()->get_main_loop()->notification(p_notification);
  830. }
  831. bool OS_JavaScript::_check_internal_feature_support(const String &p_feature) {
  832. if (p_feature == "HTML5" || p_feature == "web")
  833. return true;
  834. #ifdef JAVASCRIPT_EVAL_ENABLED
  835. if (p_feature == "JavaScript")
  836. return true;
  837. #endif
  838. EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_get_current_context();
  839. // All extensions are already automatically enabled, this function allows
  840. // checking WebGL extension support without inline JavaScript
  841. if (p_feature == "s3tc")
  842. return emscripten_webgl_enable_extension(ctx, "WEBGL_compressed_texture_s3tc_srgb");
  843. if (p_feature == "etc")
  844. return emscripten_webgl_enable_extension(ctx, "WEBGL_compressed_texture_etc1");
  845. if (p_feature == "etc2")
  846. return emscripten_webgl_enable_extension(ctx, "WEBGL_compressed_texture_etc");
  847. return false;
  848. }
  849. void OS_JavaScript::alert(const String &p_alert, const String &p_title) {
  850. /* clang-format off */
  851. EM_ASM_({
  852. window.alert(UTF8ToString($0));
  853. }, p_alert.utf8().get_data());
  854. /* clang-format on */
  855. }
  856. void OS_JavaScript::set_window_title(const String &p_title) {
  857. /* clang-format off */
  858. EM_ASM_({
  859. document.title = UTF8ToString($0);
  860. }, p_title.utf8().get_data());
  861. /* clang-format on */
  862. }
  863. void OS_JavaScript::set_icon(const Ref<Image> &p_icon) {
  864. ERR_FAIL_COND(p_icon.is_null());
  865. Ref<Image> icon = p_icon;
  866. if (icon->is_compressed()) {
  867. icon = icon->duplicate();
  868. ERR_FAIL_COND(icon->decompress() != OK)
  869. }
  870. if (icon->get_format() != Image::FORMAT_RGBA8) {
  871. if (icon == p_icon)
  872. icon = icon->duplicate();
  873. icon->convert(Image::FORMAT_RGBA8);
  874. }
  875. png_image png_meta;
  876. memset(&png_meta, 0, sizeof png_meta);
  877. png_meta.version = PNG_IMAGE_VERSION;
  878. png_meta.width = icon->get_width();
  879. png_meta.height = icon->get_height();
  880. png_meta.format = PNG_FORMAT_RGBA;
  881. PoolByteArray png;
  882. size_t len;
  883. PoolByteArray::Read r = icon->get_data().read();
  884. ERR_FAIL_COND(!png_image_write_get_memory_size(png_meta, len, 0, r.ptr(), 0, NULL));
  885. png.resize(len);
  886. PoolByteArray::Write w = png.write();
  887. ERR_FAIL_COND(!png_image_write_to_memory(&png_meta, w.ptr(), &len, 0, r.ptr(), 0, NULL));
  888. w = PoolByteArray::Write();
  889. r = png.read();
  890. /* clang-format off */
  891. EM_ASM_ARGS({
  892. var PNG_PTR = $0;
  893. var PNG_LEN = $1;
  894. var png = new Blob([HEAPU8.slice(PNG_PTR, PNG_PTR + PNG_LEN)], { type: "image/png" });
  895. var url = URL.createObjectURL(png);
  896. var link = document.getElementById('-gd-engine-icon');
  897. if (link === null) {
  898. link = document.createElement('link');
  899. link.rel = 'icon';
  900. link.id = '-gd-engine-icon';
  901. document.head.appendChild(link);
  902. }
  903. link.href = url;
  904. }, r.ptr(), len);
  905. /* clang-format on */
  906. }
  907. String OS_JavaScript::get_executable_path() const {
  908. return OS::get_executable_path();
  909. }
  910. Error OS_JavaScript::shell_open(String p_uri) {
  911. // Open URI in a new tab, browser will deal with it by protocol.
  912. /* clang-format off */
  913. EM_ASM_({
  914. window.open(UTF8ToString($0), '_blank');
  915. }, p_uri.utf8().get_data());
  916. /* clang-format on */
  917. return OK;
  918. }
  919. String OS_JavaScript::get_name() {
  920. return "HTML5";
  921. }
  922. bool OS_JavaScript::can_draw() const {
  923. return true; // Always?
  924. }
  925. String OS_JavaScript::get_user_data_dir() const {
  926. return "/userfs";
  927. };
  928. String OS_JavaScript::get_resource_dir() const {
  929. return "/";
  930. }
  931. OS::PowerState OS_JavaScript::get_power_state() {
  932. WARN_PRINT("Power management is not supported for the HTML5 platform, defaulting to POWERSTATE_UNKNOWN");
  933. return OS::POWERSTATE_UNKNOWN;
  934. }
  935. int OS_JavaScript::get_power_seconds_left() {
  936. WARN_PRINT("Power management is not supported for the HTML5 platform, defaulting to -1");
  937. return -1;
  938. }
  939. int OS_JavaScript::get_power_percent_left() {
  940. WARN_PRINT("Power management is not supported for the HTML5 platform, defaulting to -1");
  941. return -1;
  942. }
  943. void OS_JavaScript::file_access_close_callback(const String &p_file, int p_flags) {
  944. OS_JavaScript *os = get_singleton();
  945. if (os->is_userfs_persistent() && p_file.begins_with("/userfs") && p_flags & FileAccess::WRITE) {
  946. os->last_sync_check_time = OS::get_singleton()->get_ticks_msec();
  947. // Wait five seconds in case more files are about to be closed.
  948. os->sync_wait_time = 5000;
  949. }
  950. }
  951. void OS_JavaScript::set_idb_available(bool p_idb_available) {
  952. idb_available = p_idb_available;
  953. }
  954. bool OS_JavaScript::is_userfs_persistent() const {
  955. return idb_available;
  956. }
  957. OS_JavaScript *OS_JavaScript::get_singleton() {
  958. return static_cast<OS_JavaScript *>(OS::get_singleton());
  959. }
  960. OS_JavaScript::OS_JavaScript(int p_argc, char *p_argv[]) {
  961. List<String> arguments;
  962. for (int i = 1; i < p_argc; i++) {
  963. arguments.push_back(String::utf8(p_argv[i]));
  964. }
  965. set_cmdline(p_argv[0], arguments);
  966. last_click_button_index = -1;
  967. last_click_ms = 0;
  968. last_click_pos = Point2(-100, -100);
  969. window_maximized = false;
  970. entering_fullscreen = false;
  971. just_exited_fullscreen = false;
  972. main_loop = NULL;
  973. idb_available = false;
  974. sync_wait_time = -1;
  975. AudioDriverManager::add_driver(&audio_driver_javascript);
  976. Vector<Logger *> loggers;
  977. loggers.push_back(memnew(StdLogger));
  978. _set_logger(memnew(CompositeLogger(loggers)));
  979. FileAccessUnix::close_notification_func = file_access_close_callback;
  980. }