1 files changed, 196 insertions, 107 deletions

diff --git a/platform/javascript/display_server_javascript.cpp b/platform/javascript/display_server_javascript.cpp
index c2eb826db9..30240ad2db 100644
--- a/platform/javascript/display_server_javascript.cpp
+++ b/platform/javascript/display_server_javascript.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -28,10 +28,13 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "platform/javascript/display_server_javascript.h"
+#include "display_server_javascript.h"
 
+#ifdef GLES3_ENABLED
+#include "drivers/gles3/rasterizer_gles3.h"
+#endif
 #include "platform/javascript/os_javascript.h"
-#include "servers/rendering/rasterizer_dummy.h"
+#include "servers/rendering/dummy/rasterizer_dummy.h"
 
 #include <emscripten.h>
 #include <png.h>
@@ -50,14 +53,6 @@ DisplayServerJavaScript *DisplayServerJavaScript::get_singleton() {
 }
 
 // Window (canvas)
-void DisplayServerJavaScript::focus_canvas() {
-	godot_js_display_canvas_focus();
-}
-
-bool DisplayServerJavaScript::is_canvas_focused() {
-	return godot_js_display_canvas_is_focused() != 0;
-}
-
 bool DisplayServerJavaScript::check_size_force_redraw() {
 	return godot_js_display_size_update() != 0;
 }
@@ -88,7 +83,7 @@ void DisplayServerJavaScript::drop_files_js_callback(char **p_filev, int p_filec
 	Variant *vp = &v;
 	Variant ret;
 	Callable::CallError ce;
-	ds->drop_files_callback.call((const Variant **)&vp, 1, ret, ce);
+	ds->drop_files_callback.callp((const Variant **)&vp, 1, ret, ce);
 }
 
 // JavaScript quit request callback.
@@ -99,7 +94,7 @@ void DisplayServerJavaScript::request_quit_callback() {
 		Variant *eventp = &event;
 		Variant ret;
 		Callable::CallError ce;
-		ds->window_event_callback.call((const Variant **)&eventp, 1, ret, ce);
+		ds->window_event_callback.callp((const Variant **)&eventp, 1, ret, ce);
 	}
 }
 
@@ -141,29 +136,29 @@ void DisplayServerJavaScript::key_callback(int p_pressed, int p_repeat, int p_mo
 int DisplayServerJavaScript::mouse_button_callback(int p_pressed, int p_button, double p_x, double p_y, int p_modifiers) {
 	DisplayServerJavaScript *ds = get_singleton();
 
+	Point2 pos(p_x, p_y);
 	Ref<InputEventMouseButton> ev;
 	ev.instantiate();
-	ev->set_pressed(p_pressed);
-	ev->set_position(Point2(p_x, p_y));
-	ev->set_global_position(ev->get_position());
+	ev->set_position(pos);
+	ev->set_global_position(pos);
 	ev->set_pressed(p_pressed);
 	dom2godot_mod(ev, p_modifiers);
 
 	switch (p_button) {
 		case DOM_BUTTON_LEFT:
-			ev->set_button_index(MOUSE_BUTTON_LEFT);
+			ev->set_button_index(MouseButton::LEFT);
 			break;
 		case DOM_BUTTON_MIDDLE:
-			ev->set_button_index(MOUSE_BUTTON_MIDDLE);
+			ev->set_button_index(MouseButton::MIDDLE);
 			break;
 		case DOM_BUTTON_RIGHT:
-			ev->set_button_index(MOUSE_BUTTON_RIGHT);
+			ev->set_button_index(MouseButton::RIGHT);
 			break;
 		case DOM_BUTTON_XBUTTON1:
-			ev->set_button_index(MOUSE_BUTTON_XBUTTON1);
+			ev->set_button_index(MouseButton::MB_XBUTTON1);
 			break;
 		case DOM_BUTTON_XBUTTON2:
-			ev->set_button_index(MOUSE_BUTTON_XBUTTON2);
+			ev->set_button_index(MouseButton::MB_XBUTTON2);
 			break;
 		default:
 			return false;
@@ -176,7 +171,7 @@ int DisplayServerJavaScript::mouse_button_callback(int p_pressed, int p_button,
 			if (diff < 400 && Point2(ds->last_click_pos).distance_to(ev->get_position()) < 5) {
 				ds->last_click_ms = 0;
 				ds->last_click_pos = Point2(-100, -100);
-				ds->last_click_button_index = -1;
+				ds->last_click_button_index = MouseButton::NONE;
 				ev->set_double_click(true);
 			}
 
@@ -190,11 +185,11 @@ int DisplayServerJavaScript::mouse_button_callback(int p_pressed, int p_button,
 		}
 	}
 
-	int mask = Input::get_singleton()->get_mouse_button_mask();
-	int button_flag = 1 << (ev->get_button_index() - 1);
+	MouseButton mask = Input::get_singleton()->get_mouse_button_mask();
+	MouseButton button_flag = mouse_button_to_mask(ev->get_button_index());
 	if (ev->is_pressed()) {
 		mask |= button_flag;
-	} else if (mask & button_flag) {
+	} else if ((mask & button_flag) != MouseButton::NONE) {
 		mask &= ~button_flag;
 	} else {
 		// Received release event, but press was outside the canvas, so ignore.
@@ -215,23 +210,24 @@ int DisplayServerJavaScript::mouse_button_callback(int p_pressed, int p_button,
 }
 
 void DisplayServerJavaScript::mouse_move_callback(double p_x, double p_y, double p_rel_x, double p_rel_y, int p_modifiers) {
-	int input_mask = Input::get_singleton()->get_mouse_button_mask();
+	MouseButton input_mask = Input::get_singleton()->get_mouse_button_mask();
 	// For motion outside the canvas, only read mouse movement if dragging
 	// started inside the canvas; imitating desktop app behaviour.
-	if (!get_singleton()->cursor_inside_canvas && !input_mask)
+	if (!get_singleton()->cursor_inside_canvas && input_mask == MouseButton::NONE) {
 		return;
+	}
 
+	Point2 pos(p_x, p_y);
 	Ref<InputEventMouseMotion> ev;
 	ev.instantiate();
 	dom2godot_mod(ev, p_modifiers);
 	ev->set_button_mask(input_mask);
 
-	ev->set_position(Point2(p_x, p_y));
-	ev->set_global_position(ev->get_position());
+	ev->set_position(pos);
+	ev->set_global_position(pos);
 
 	ev->set_relative(Vector2(p_rel_x, p_rel_y));
-	Input::get_singleton()->set_mouse_position(ev->get_position());
-	ev->set_speed(Input::get_singleton()->get_last_mouse_speed());
+	ev->set_velocity(Input::get_singleton()->get_last_mouse_velocity());
 
 	Input::get_singleton()->parse_input_event(ev);
 }
@@ -240,7 +236,7 @@ void DisplayServerJavaScript::mouse_move_callback(double p_x, double p_y, double
 const char *DisplayServerJavaScript::godot2dom_cursor(DisplayServer::CursorShape p_shape) {
 	switch (p_shape) {
 		case DisplayServer::CURSOR_ARROW:
-			return "auto";
+			return "default";
 		case DisplayServer::CURSOR_IBEAM:
 			return "text";
 		case DisplayServer::CURSOR_POINTING_HAND:
@@ -248,9 +244,9 @@ const char *DisplayServerJavaScript::godot2dom_cursor(DisplayServer::CursorShape
 		case DisplayServer::CURSOR_CROSS:
 			return "crosshair";
 		case DisplayServer::CURSOR_WAIT:
-			return "progress";
-		case DisplayServer::CURSOR_BUSY:
 			return "wait";
+		case DisplayServer::CURSOR_BUSY:
+			return "progress";
 		case DisplayServer::CURSOR_DRAG:
 			return "grab";
 		case DisplayServer::CURSOR_CAN_DROP:
@@ -274,7 +270,91 @@ const char *DisplayServerJavaScript::godot2dom_cursor(DisplayServer::CursorShape
 		case DisplayServer::CURSOR_HELP:
 			return "help";
 		default:
-			return "auto";
+			return "default";
+	}
+}
+
+bool DisplayServerJavaScript::tts_is_speaking() const {
+	return godot_js_tts_is_speaking();
+}
+
+bool DisplayServerJavaScript::tts_is_paused() const {
+	return godot_js_tts_is_paused();
+}
+
+void DisplayServerJavaScript::update_voices_callback(int p_size, const char **p_voice) {
+	get_singleton()->voices.clear();
+	for (int i = 0; i < p_size; i++) {
+		Vector<String> tokens = String::utf8(p_voice[i]).split(";", true, 2);
+		if (tokens.size() == 2) {
+			Dictionary voice_d;
+			voice_d["name"] = tokens[1];
+			voice_d["id"] = tokens[1];
+			voice_d["language"] = tokens[0];
+			get_singleton()->voices.push_back(voice_d);
+		}
+	}
+}
+
+TypedArray<Dictionary> DisplayServerJavaScript::tts_get_voices() const {
+	godot_js_tts_get_voices(update_voices_callback);
+	return voices;
+}
+
+void DisplayServerJavaScript::tts_speak(const String &p_text, const String &p_voice, int p_volume, float p_pitch, float p_rate, int p_utterance_id, bool p_interrupt) {
+	if (p_interrupt) {
+		tts_stop();
+	}
+
+	if (p_text.is_empty()) {
+		tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, p_utterance_id);
+		return;
+	}
+
+	CharString string = p_text.utf8();
+	utterance_ids[p_utterance_id] = string;
+
+	godot_js_tts_speak(string.get_data(), p_voice.utf8().get_data(), CLAMP(p_volume, 0, 100), CLAMP(p_pitch, 0.f, 2.f), CLAMP(p_rate, 0.1f, 10.f), p_utterance_id, DisplayServerJavaScript::_js_utterance_callback);
+}
+
+void DisplayServerJavaScript::tts_pause() {
+	godot_js_tts_pause();
+}
+
+void DisplayServerJavaScript::tts_resume() {
+	godot_js_tts_resume();
+}
+
+void DisplayServerJavaScript::tts_stop() {
+	for (const KeyValue<int, CharString> &E : utterance_ids) {
+		tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, E.key);
+	}
+	utterance_ids.clear();
+	godot_js_tts_stop();
+}
+
+void DisplayServerJavaScript::_js_utterance_callback(int p_event, int p_id, int p_pos) {
+	DisplayServerJavaScript *ds = (DisplayServerJavaScript *)DisplayServer::get_singleton();
+	if (ds->utterance_ids.has(p_id)) {
+		int pos = 0;
+		if ((TTSUtteranceEvent)p_event == DisplayServer::TTS_UTTERANCE_BOUNDARY) {
+			// Convert position from UTF-8 to UTF-32.
+			const CharString &string = ds->utterance_ids[p_id];
+			for (int i = 0; i < MIN(p_pos, string.length()); i++) {
+				uint8_t c = string[i];
+				if ((c & 0xe0) == 0xc0) {
+					i += 1;
+				} else if ((c & 0xf0) == 0xe0) {
+					i += 2;
+				} else if ((c & 0xf8) == 0xf0) {
+					i += 3;
+				}
+				pos++;
+			}
+		} else if ((TTSUtteranceEvent)p_event != DisplayServer::TTS_UTTERANCE_STARTED) {
+			ds->utterance_ids.erase(p_id);
+		}
+		ds->tts_post_utterance_event((TTSUtteranceEvent)p_event, p_id, pos);
 	}
 }
 
@@ -291,7 +371,7 @@ DisplayServer::CursorShape DisplayServerJavaScript::cursor_get_shape() const {
 	return cursor_shape;
 }
 
-void DisplayServerJavaScript::cursor_set_custom_image(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
+void DisplayServerJavaScript::cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
 	if (p_cursor.is_valid()) {
 		Ref<Texture2D> texture = p_cursor;
 		Ref<AtlasTexture> atlas_texture = p_cursor;
@@ -329,12 +409,13 @@ void DisplayServerJavaScript::cursor_set_custom_image(const RES &p_cursor, Curso
 
 		image = image->duplicate();
 
-		if (atlas_texture.is_valid())
+		if (atlas_texture.is_valid()) {
 			image->crop_from_point(
 					atlas_rect.position.x,
 					atlas_rect.position.y,
 					texture_size.width,
 					texture_size.height);
+		}
 
 		if (image->get_format() != Image::FORMAT_RGBA8) {
 			image->convert(Image::FORMAT_RGBA8);
@@ -396,6 +477,10 @@ DisplayServer::MouseMode DisplayServerJavaScript::mouse_get_mode() const {
 	return MOUSE_MODE_VISIBLE;
 }
 
+Point2i DisplayServerJavaScript::mouse_get_position() const {
+	return Input::get_singleton()->get_mouse_position();
+}
+
 // Wheel
 int DisplayServerJavaScript::mouse_wheel_callback(double p_delta_x, double p_delta_y) {
 	if (!godot_js_display_canvas_is_focused()) {
@@ -412,19 +497,19 @@ int DisplayServerJavaScript::mouse_wheel_callback(double p_delta_x, double p_del
 	ev->set_position(input->get_mouse_position());
 	ev->set_global_position(ev->get_position());
 
-	ev->set_shift_pressed(input->is_key_pressed(KEY_SHIFT));
-	ev->set_alt_pressed(input->is_key_pressed(KEY_ALT));
-	ev->set_ctrl_pressed(input->is_key_pressed(KEY_CTRL));
-	ev->set_meta_pressed(input->is_key_pressed(KEY_META));
+	ev->set_shift_pressed(input->is_key_pressed(Key::SHIFT));
+	ev->set_alt_pressed(input->is_key_pressed(Key::ALT));
+	ev->set_ctrl_pressed(input->is_key_pressed(Key::CTRL));
+	ev->set_meta_pressed(input->is_key_pressed(Key::META));
 
 	if (p_delta_y < 0) {
-		ev->set_button_index(MOUSE_BUTTON_WHEEL_UP);
+		ev->set_button_index(MouseButton::WHEEL_UP);
 	} else if (p_delta_y > 0) {
-		ev->set_button_index(MOUSE_BUTTON_WHEEL_DOWN);
+		ev->set_button_index(MouseButton::WHEEL_DOWN);
 	} else if (p_delta_x > 0) {
-		ev->set_button_index(MOUSE_BUTTON_WHEEL_LEFT);
+		ev->set_button_index(MouseButton::WHEEL_LEFT);
 	} else if (p_delta_x < 0) {
-		ev->set_button_index(MOUSE_BUTTON_WHEEL_RIGHT);
+		ev->set_button_index(MouseButton::WHEEL_RIGHT);
 	} else {
 		return false;
 	}
@@ -432,7 +517,7 @@ int DisplayServerJavaScript::mouse_wheel_callback(double p_delta_x, double p_del
 	// Different browsers give wildly different delta values, and we can't
 	// interpret deltaMode, so use default value for wheel events' factor.
 
-	int button_flag = 1 << (ev->get_button_index() - 1);
+	MouseButton button_flag = mouse_button_to_mask(ev->get_button_index());
 
 	ev->set_pressed(true);
 	ev->set_button_mask(input->get_mouse_button_mask() | button_flag);
@@ -497,11 +582,11 @@ void DisplayServerJavaScript::vk_input_text_callback(const char *p_text, int p_c
 		return;
 	}
 	// Call input_text
-	Variant event = String(p_text);
+	Variant event = String::utf8(p_text);
 	Variant *eventp = &event;
 	Variant ret;
 	Callable::CallError ce;
-	ds->input_text_callback.call((const Variant **)&eventp, 1, ret, ce);
+	ds->input_text_callback.callp((const Variant **)&eventp, 1, ret, ce);
 	// Insert key right to reach position.
 	Input *input = Input::get_singleton();
 	Ref<InputEventKey> k;
@@ -509,18 +594,18 @@ void DisplayServerJavaScript::vk_input_text_callback(const char *p_text, int p_c
 		k.instantiate();
 		k->set_pressed(true);
 		k->set_echo(false);
-		k->set_keycode(KEY_RIGHT);
+		k->set_keycode(Key::RIGHT);
 		input->parse_input_event(k);
 		k.instantiate();
 		k->set_pressed(false);
 		k->set_echo(false);
-		k->set_keycode(KEY_RIGHT);
+		k->set_keycode(Key::RIGHT);
 		input->parse_input_event(k);
 	}
 }
 
-void DisplayServerJavaScript::virtual_keyboard_show(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) {
-	godot_js_display_vk_show(p_existing_text.utf8().get_data(), p_multiline, p_cursor_start, p_cursor_end);
+void DisplayServerJavaScript::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, VirtualKeyboardType p_type, int p_max_input_length, int p_cursor_start, int p_cursor_end) {
+	godot_js_display_vk_show(p_existing_text.utf8().get_data(), p_type, p_cursor_start, p_cursor_end);
 }
 
 void DisplayServerJavaScript::virtual_keyboard_hide() {
@@ -555,37 +640,31 @@ void DisplayServerJavaScript::process_joypads() {
 			continue;
 		}
 		for (int b = 0; b < s_btns_num; b++) {
-			float value = s_btns[b];
 			// Buttons 6 and 7 in the standard mapping need to be
-			// axis to be handled as JOY_AXIS_TRIGGER by Godot.
+			// axis to be handled as JoyAxis::TRIGGER by Godot.
 			if (s_standard && (b == 6 || b == 7)) {
-				Input::JoyAxisValue joy_axis;
-				joy_axis.min = 0;
-				joy_axis.value = value;
-				JoyAxis a = b == 6 ? JOY_AXIS_TRIGGER_LEFT : JOY_AXIS_TRIGGER_RIGHT;
-				input->joy_axis(idx, a, joy_axis);
+				input->joy_axis(idx, (JoyAxis)b, s_btns[b]);
 			} else {
-				input->joy_button(idx, (JoyButton)b, value);
+				input->joy_button(idx, (JoyButton)b, s_btns[b]);
 			}
 		}
 		for (int a = 0; a < s_axes_num; a++) {
-			Input::JoyAxisValue joy_axis;
-			joy_axis.min = -1;
-			joy_axis.value = s_axes[a];
-			input->joy_axis(idx, (JoyAxis)a, joy_axis);
+			input->joy_axis(idx, (JoyAxis)a, s_axes[a]);
 		}
 	}
 }
 
 Vector<String> DisplayServerJavaScript::get_rendering_drivers_func() {
 	Vector<String> drivers;
-	drivers.push_back("dummy");
+#ifdef GLES3_ENABLED
+	drivers.push_back("opengl3");
+#endif
 	return drivers;
 }
 
 // Clipboard
 void DisplayServerJavaScript::update_clipboard_callback(const char *p_text) {
-	get_singleton()->clipboard = p_text;
+	get_singleton()->clipboard = String::utf8(p_text);
 }
 
 void DisplayServerJavaScript::clipboard_set(const String &p_text) {
@@ -612,7 +691,7 @@ void DisplayServerJavaScript::send_window_event_callback(int p_notification) {
 		Variant *eventp = &event;
 		Variant ret;
 		Callable::CallError ce;
-		ds->window_event_callback.call((const Variant **)&eventp, 1, ret, ce);
+		ds->window_event_callback.callp((const Variant **)&eventp, 1, ret, ce);
 	}
 }
 
@@ -624,8 +703,9 @@ void DisplayServerJavaScript::set_icon(const Ref<Image> &p_icon) {
 		ERR_FAIL_COND(icon->decompress() != OK);
 	}
 	if (icon->get_format() != Image::FORMAT_RGBA8) {
-		if (icon == p_icon)
+		if (icon == p_icon) {
 			icon = icon->duplicate();
+		}
 		icon->convert(Image::FORMAT_RGBA8);
 	}
 
@@ -654,7 +734,7 @@ void DisplayServerJavaScript::_dispatch_input_event(const Ref<InputEvent> &p_eve
 		Variant *evp = &ev;
 		Variant ret;
 		Callable::CallError ce;
-		cb.call((const Variant **)&evp, 1, ret, ce);
+		cb.callp((const Variant **)&evp, 1, ret, ce);
 	}
 }
 
@@ -669,7 +749,7 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 	godot_js_config_canvas_id_get(canvas_id, 256);
 
 	// Handle contextmenu, webglcontextlost
-	godot_js_display_setup_canvas(p_resolution.x, p_resolution.y, p_window_mode == WINDOW_MODE_FULLSCREEN, OS::get_singleton()->is_hidpi_allowed() ? 1 : 0);
+	godot_js_display_setup_canvas(p_resolution.x, p_resolution.y, (p_window_mode == WINDOW_MODE_FULLSCREEN || p_window_mode == WINDOW_MODE_EXCLUSIVE_FULLSCREEN), OS::get_singleton()->is_hidpi_allowed() ? 1 : 0);
 
 	// Check if it's windows.
 	swap_cancel_ok = godot_js_display_is_swap_ok_cancel() == 1;
@@ -677,40 +757,34 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 	// Expose method for requesting quit.
 	godot_js_os_request_quit_cb(request_quit_callback);
 
-	RasterizerDummy::make_current(); // TODO GLES2 in Godot 4.0... or webgpu?
-#if 0
-	EmscriptenWebGLContextAttributes attributes;
-	emscripten_webgl_init_context_attributes(&attributes);
-	attributes.alpha = GLOBAL_GET("display/window/per_pixel_transparency/allowed");
-	attributes.antialias = false;
-	ERR_FAIL_INDEX_V(p_video_driver, VIDEO_DRIVER_MAX, ERR_INVALID_PARAMETER);
-
-	if (p_desired.layered) {
-		set_window_per_pixel_transparency_enabled(true);
-	}
-
-	bool gl_initialization_error = false;
-
-	if (RasterizerGLES2::is_viable() == OK) {
-		attributes.majorVersion = 1;
-		RasterizerGLES2::register_config();
-		RasterizerGLES2::make_current();
-	} else {
-		gl_initialization_error = true;
-	}
-
-	EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(canvas_id, &attributes);
-	if (emscripten_webgl_make_context_current(ctx) != EMSCRIPTEN_RESULT_SUCCESS) {
-		gl_initialization_error = true;
+#ifdef GLES3_ENABLED
+	// TODO "vulkan" defaults to webgl2 for now.
+	bool wants_webgl2 = p_rendering_driver == "opengl3" || p_rendering_driver == "vulkan";
+	bool webgl2_init_failed = wants_webgl2 && !godot_js_display_has_webgl(2);
+	if (wants_webgl2 && !webgl2_init_failed) {
+		EmscriptenWebGLContextAttributes attributes;
+		emscripten_webgl_init_context_attributes(&attributes);
+		//attributes.alpha = GLOBAL_GET("display/window/per_pixel_transparency/allowed");
+		attributes.alpha = true;
+		attributes.antialias = false;
+		attributes.majorVersion = 2;
+
+		webgl_ctx = emscripten_webgl_create_context(canvas_id, &attributes);
+		if (emscripten_webgl_make_context_current(webgl_ctx) != EMSCRIPTEN_RESULT_SUCCESS) {
+			webgl2_init_failed = true;
+		} else {
+			RasterizerGLES3::make_current();
+		}
 	}
-
-	if (gl_initialization_error) {
-		OS::get_singleton()->alert("Your browser does not seem to support WebGL. Please update your browser version.",
+	if (webgl2_init_failed) {
+		OS::get_singleton()->alert("Your browser does not seem to support WebGL2. Please update your browser version.",
 				"Unable to initialize video driver");
-		return ERR_UNAVAILABLE;
 	}
-
-	video_driver_index = p_video_driver;
+	if (!wants_webgl2 || webgl2_init_failed) {
+		RasterizerDummy::make_current();
+	}
+#else
+	RasterizerDummy::make_current();
 #endif
 
 	// JS Input interface (js/libs/library_godot_input.js)
@@ -737,13 +811,16 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 }
 
 DisplayServerJavaScript::~DisplayServerJavaScript() {
-	//emscripten_webgl_commit_frame();
-	//emscripten_webgl_destroy_context(webgl_ctx);
+#ifdef GLES3_ENABLED
+	if (webgl_ctx) {
+		emscripten_webgl_commit_frame();
+		emscripten_webgl_destroy_context(webgl_ctx);
+	}
+#endif
 }
 
 bool DisplayServerJavaScript::has_feature(Feature p_feature) const {
 	switch (p_feature) {
-		//case FEATURE_CONSOLE_WINDOW:
 		//case FEATURE_GLOBAL_MENU:
 		//case FEATURE_HIDPI:
 		//case FEATURE_IME:
@@ -762,6 +839,8 @@ bool DisplayServerJavaScript::has_feature(Feature p_feature) const {
 		//case FEATURE_ORIENTATION:
 		case FEATURE_VIRTUAL_KEYBOARD:
 			return godot_js_display_vk_available() != 0;
+		case FEATURE_TEXT_TO_SPEECH:
+			return godot_js_display_tts_available() != 0;
 		default:
 			return false;
 	}
@@ -803,6 +882,10 @@ float DisplayServerJavaScript::screen_get_scale(int p_screen) const {
 	return godot_js_display_pixel_ratio_get();
 }
 
+float DisplayServerJavaScript::screen_get_refresh_rate(int p_screen) const {
+	return SCREEN_REFRESH_RATE_FALLBACK; // Javascript doesn't have much of a need for the screen refresh rate, and there's no native way to do so.
+}
+
 Vector<DisplayServer::WindowID> DisplayServerJavaScript::get_window_list() const {
 	Vector<WindowID> ret;
 	ret.push_back(MAIN_WINDOW_ID);
@@ -896,8 +979,9 @@ Size2i DisplayServerJavaScript::window_get_real_size(WindowID p_window) const {
 }
 
 void DisplayServerJavaScript::window_set_mode(WindowMode p_mode, WindowID p_window) {
-	if (window_mode == p_mode)
+	if (window_mode == p_mode) {
 		return;
+	}
 
 	switch (p_mode) {
 		case WINDOW_MODE_WINDOWED: {
@@ -906,6 +990,7 @@ void DisplayServerJavaScript::window_set_mode(WindowMode p_mode, WindowID p_wind
 			}
 			window_mode = WINDOW_MODE_WINDOWED;
 		} break;
+		case WINDOW_MODE_EXCLUSIVE_FULLSCREEN:
 		case WINDOW_MODE_FULLSCREEN: {
 			int result = godot_js_display_fullscreen_request();
 			ERR_FAIL_COND_MSG(result, "The request was denied. Remember that enabling fullscreen is only possible from an input callback for the HTML5 platform.");
@@ -967,5 +1052,9 @@ bool DisplayServerJavaScript::get_swap_cancel_ok() {
 }
 
 void DisplayServerJavaScript::swap_buffers() {
-	//emscripten_webgl_commit_frame();
+#ifdef GLES3_ENABLED
+	if (webgl_ctx) {
+		emscripten_webgl_commit_frame();
+	}
+#endif
 }