godot/modules/webxr/webxr_interface_js.cpp

/*************************************************************************/
/*  webxr_interface_js.cpp                                               */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* 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       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#ifdef JAVASCRIPT_ENABLED

#include "webxr_interface_js.h"
#include "core/os/input.h"
#include "core/os/os.h"
#include "emscripten.h"
#include "godot_webxr.h"
#include "main/input_default.h"
#include "servers/visual/visual_server_globals.h"
#include <stdlib.h>

void _emwebxr_on_session_supported(char *p_session_mode, int p_supported) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	String session_mode = String(p_session_mode);
	interface->emit_signal("session_supported", session_mode, p_supported ? true : false);
}

void _emwebxr_on_session_started(char *p_reference_space_type) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	String reference_space_type = String(p_reference_space_type);
	((WebXRInterfaceJS *)interface.ptr())->_set_reference_space_type(reference_space_type);
	interface->emit_signal("session_started");
}

void _emwebxr_on_session_ended() {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	interface->uninitialize();
	interface->emit_signal("session_ended");
}

void _emwebxr_on_session_failed(char *p_message) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	interface->uninitialize();

	String message = String(p_message);
	interface->emit_signal("session_failed", message);
}

void _emwebxr_on_controller_changed() {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	((WebXRInterfaceJS *)interface.ptr())->_on_controller_changed();
}

extern "C" EMSCRIPTEN_KEEPALIVE void _emwebxr_on_input_event(int p_event_type, int p_input_source) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	((WebXRInterfaceJS *)interface.ptr())->_on_input_event(p_event_type, p_input_source);
}

extern "C" EMSCRIPTEN_KEEPALIVE void _emwebxr_on_simple_event(char *p_signal_name) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRInterface> interface = arvr_server->find_interface("WebXR");
	ERR_FAIL_COND(interface.is_null());

	StringName signal_name = StringName(p_signal_name);
	interface->emit_signal(signal_name);
}

void WebXRInterfaceJS::is_session_supported(const String &p_session_mode) {
	godot_webxr_is_session_supported(p_session_mode.utf8().get_data(), &_emwebxr_on_session_supported);
}

void WebXRInterfaceJS::set_session_mode(String p_session_mode) {
	session_mode = p_session_mode;
}

String WebXRInterfaceJS::get_session_mode() const {
	return session_mode;
}

void WebXRInterfaceJS::set_required_features(String p_required_features) {
	required_features = p_required_features;
}

String WebXRInterfaceJS::get_required_features() const {
	return required_features;
}

void WebXRInterfaceJS::set_optional_features(String p_optional_features) {
	optional_features = p_optional_features;
}

String WebXRInterfaceJS::get_optional_features() const {
	return optional_features;
}

void WebXRInterfaceJS::set_requested_reference_space_types(String p_requested_reference_space_types) {
	requested_reference_space_types = p_requested_reference_space_types;
}

String WebXRInterfaceJS::get_requested_reference_space_types() const {
	return requested_reference_space_types;
}

void WebXRInterfaceJS::_set_reference_space_type(String p_reference_space_type) {
	reference_space_type = p_reference_space_type;
}

String WebXRInterfaceJS::get_reference_space_type() const {
	return reference_space_type;
}

Ref<ARVRPositionalTracker> WebXRInterfaceJS::get_controller(int p_controller_id) const {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL_V(arvr_server, nullptr);

	return arvr_server->find_by_type_and_id(ARVRServer::TRACKER_CONTROLLER, p_controller_id);
}

WebXRInterface::TargetRayMode WebXRInterfaceJS::get_controller_target_ray_mode(int p_controller_id) const {
	ERR_FAIL_COND_V(p_controller_id <= 0, WebXRInterface::TARGET_RAY_MODE_UNKNOWN);

	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL_V(arvr_server, WebXRInterface::TARGET_RAY_MODE_UNKNOWN);

	return (WebXRInterface::TargetRayMode)godot_webxr_get_controller_target_ray_mode(p_controller_id - 1);
}

String WebXRInterfaceJS::get_visibility_state() const {
	char *c_str = godot_webxr_get_visibility_state();
	if (c_str) {
		String visibility_state = String(c_str);
		free(c_str);

		return visibility_state;
	}
	return String();
}

PoolVector3Array WebXRInterfaceJS::get_bounds_geometry() const {
	PoolVector3Array ret;

	int *js_bounds = godot_webxr_get_bounds_geometry();
	if (js_bounds) {
		ret.resize(js_bounds[0]);
		for (int i = 0; i < js_bounds[0]; i++) {
			float *js_vector3 = ((float *)js_bounds) + (i * 3) + 1;
			ret.set(i, Vector3(js_vector3[0], js_vector3[1], js_vector3[2]));
		}
		free(js_bounds);
	}

	return ret;
}

void WebXRInterfaceJS::set_xr_standard_mapping(bool p_xr_standard_mapping) {
	xr_standard_mapping = p_xr_standard_mapping;
}

bool WebXRInterfaceJS::get_xr_standard_mapping() const {
	return xr_standard_mapping;
}

StringName WebXRInterfaceJS::get_name() const {
	return "WebXR";
};

int WebXRInterfaceJS::get_capabilities() const {
	return ARVRInterface::ARVR_STEREO | ARVRInterface::ARVR_MONO;
};

bool WebXRInterfaceJS::is_stereo() {
	return godot_webxr_get_view_count() == 2;
};

bool WebXRInterfaceJS::is_initialized() const {
	return (initialized);
};

bool WebXRInterfaceJS::initialize() {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL_V(arvr_server, false);

	if (!initialized) {
		if (!godot_webxr_is_supported()) {
			return false;
		}

		if (requested_reference_space_types.size() == 0) {
			return false;
		}

		// make this our primary interface
		arvr_server->set_primary_interface(this);

		// Clear state variables.
		memset(controllers_state, 0, sizeof controllers_state);
		memset(touching, 0, sizeof touching);

		// Clear render_targetsize to make sure it gets reset to the new size.
		// Clearing in uninitialize() doesn't work because a frame can still be
		// rendered after it's called, which will fill render_targetsize again.
		render_targetsize.width = 0;
		render_targetsize.height = 0;

		initialized = true;

		godot_webxr_initialize(
				session_mode.utf8().get_data(),
				required_features.utf8().get_data(),
				optional_features.utf8().get_data(),
				requested_reference_space_types.utf8().get_data(),
				&_emwebxr_on_session_started,
				&_emwebxr_on_session_ended,
				&_emwebxr_on_session_failed,
				&_emwebxr_on_controller_changed,
				&_emwebxr_on_input_event,
				&_emwebxr_on_simple_event);
	};

	return true;
};

void WebXRInterfaceJS::uninitialize() {
	if (initialized) {
		ARVRServer *arvr_server = ARVRServer::get_singleton();
		if (arvr_server != NULL) {
			// no longer our primary interface
			arvr_server->clear_primary_interface_if(this);
		}

		godot_webxr_uninitialize();

		reference_space_type = "";
		initialized = false;
	};
};

Transform WebXRInterfaceJS::_js_matrix_to_transform(float *p_js_matrix) {
	Transform transform;

	transform.basis.elements[0].x = p_js_matrix[0];
	transform.basis.elements[1].x = p_js_matrix[1];
	transform.basis.elements[2].x = p_js_matrix[2];
	transform.basis.elements[0].y = p_js_matrix[4];
	transform.basis.elements[1].y = p_js_matrix[5];
	transform.basis.elements[2].y = p_js_matrix[6];
	transform.basis.elements[0].z = p_js_matrix[8];
	transform.basis.elements[1].z = p_js_matrix[9];
	transform.basis.elements[2].z = p_js_matrix[10];
	transform.origin.x = p_js_matrix[12];
	transform.origin.y = p_js_matrix[13];
	transform.origin.z = p_js_matrix[14];

	return transform;
}

Size2 WebXRInterfaceJS::get_render_targetsize() {
	if (render_targetsize.width != 0 && render_targetsize.height != 0) {
		return render_targetsize;
	}

	int *js_size = godot_webxr_get_render_targetsize();
	if (!initialized || js_size == nullptr) {
		// As a temporary default (until WebXR is fully initialized), use half the window size.
		Size2 temp = OS::get_singleton()->get_window_size();
		temp.width /= 2.0;
		return temp;
	}

	render_targetsize.width = js_size[0];
	render_targetsize.height = js_size[1];

	free(js_size);

	return render_targetsize;
};

Transform WebXRInterfaceJS::get_transform_for_eye(ARVRInterface::Eyes p_eye, const Transform &p_cam_transform) {
	Transform transform_for_eye;

	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL_V(arvr_server, transform_for_eye);

	float *js_matrix = godot_webxr_get_transform_for_eye(p_eye);
	if (!initialized || js_matrix == nullptr) {
		transform_for_eye = p_cam_transform;
		return transform_for_eye;
	}

	transform_for_eye = _js_matrix_to_transform(js_matrix);
	free(js_matrix);

	return p_cam_transform * arvr_server->get_reference_frame() * transform_for_eye;
};

CameraMatrix WebXRInterfaceJS::get_projection_for_eye(ARVRInterface::Eyes p_eye, real_t p_aspect, real_t p_z_near, real_t p_z_far) {
	CameraMatrix eye;

	float *js_matrix = godot_webxr_get_projection_for_eye(p_eye);
	if (!initialized || js_matrix == nullptr) {
		return eye;
	}

	int k = 0;
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			eye.matrix[i][j] = js_matrix[k++];
		}
	}

	free(js_matrix);

	// Copied from godot_oculus_mobile's ovr_mobile_session.cpp
	eye.matrix[2][2] = -(p_z_far + p_z_near) / (p_z_far - p_z_near);
	eye.matrix[3][2] = -(2.0f * p_z_far * p_z_near) / (p_z_far - p_z_near);

	return eye;
}

void WebXRInterfaceJS::commit_for_eye(ARVRInterface::Eyes p_eye, RID p_render_target, const Rect2 &p_screen_rect) {
	if (!initialized) {
		return;
	}

	RID texture = VSG::storage->render_target_get_texture(p_render_target);
	uint32_t texture_id = VSG::storage->texture_get_texid(texture);

	godot_webxr_commit_for_eye(p_eye, texture_id);
};

void WebXRInterfaceJS::process() {
	if (initialized) {
		godot_webxr_sample_controller_data();

		int controller_count = godot_webxr_get_controller_count();
		if (controller_count == 0) {
			return;
		}

		for (int i = 0; i < controller_count; i++) {
			_update_tracker(i);
		}
	};
};

void WebXRInterfaceJS::_update_tracker(int p_controller_id) {
	ARVRServer *arvr_server = ARVRServer::get_singleton();
	ERR_FAIL_NULL(arvr_server);

	Ref<ARVRPositionalTracker> tracker = arvr_server->find_by_type_and_id(ARVRServer::TRACKER_CONTROLLER, p_controller_id + 1);
	if (godot_webxr_is_controller_connected(p_controller_id)) {
		if (tracker.is_null()) {
			tracker.instance();
			tracker->set_type(ARVRServer::TRACKER_CONTROLLER);
			// Controller id's 0 and 1 are always the left and right hands.
			if (p_controller_id < 2) {
				tracker->set_name(p_controller_id == 0 ? "Left" : "Right");
				tracker->set_hand(p_controller_id == 0 ? ARVRPositionalTracker::TRACKER_LEFT_HAND : ARVRPositionalTracker::TRACKER_RIGHT_HAND);
			}
			// Use the ids we're giving to our "virtual" gamepads.
			tracker->set_joy_id(p_controller_id + 100);
			arvr_server->add_tracker(tracker);
		}

		InputDefault *input = (InputDefault *)Input::get_singleton();
		int joy_id = p_controller_id + 100;

		float *tracker_matrix = godot_webxr_get_controller_transform(p_controller_id);
		if (tracker_matrix) {
			Transform transform = _js_matrix_to_transform(tracker_matrix);
			tracker->set_position(transform.origin);
			tracker->set_orientation(transform.basis);
			free(tracker_matrix);
		}

		int *buttons = godot_webxr_get_controller_buttons(p_controller_id, xr_standard_mapping);
		if (buttons) {
			for (int i = 0; i < buttons[0]; i++) {
				input->joy_button(joy_id, i, *((float *)buttons + (i + 1)));
			}
			free(buttons);
		}

		int *axes = godot_webxr_get_controller_axes(p_controller_id, xr_standard_mapping);
		if (axes) {
			WebXRInterface::TargetRayMode target_ray_mode = (WebXRInterface::TargetRayMode)godot_webxr_get_controller_target_ray_mode(p_controller_id);
			if (target_ray_mode == WebXRInterface::TARGET_RAY_MODE_SCREEN) {
				int touch_index = _get_touch_index(p_controller_id);
				if (touch_index < 5 && touching[touch_index]) {
					Vector2 joy_vector = _get_joy_vector_from_axes(axes);
					Vector2 previous_joy_vector(input->get_joy_axis(joy_id, 0), input->get_joy_axis(joy_id, 1));

					if (!joy_vector.is_equal_approx(previous_joy_vector)) {
						Vector2 position = _get_screen_position_from_joy_vector(joy_vector);
						Vector2 previous_position = _get_screen_position_from_joy_vector(previous_joy_vector);

						Ref<InputEventScreenDrag> event;
						event.instance();
						event->set_index(touch_index);
						event->set_position(position);
						event->set_relative(position - previous_position);
						input->parse_input_event(event);
					}
				}
			}

			for (int i = 0; i < axes[0]; i++) {
				float value = *((float *)axes + (i + 1));
				input->joy_axis(joy_id, i, value);
			}

			free(axes);
		}
	} else if (tracker.is_valid()) {
		arvr_server->remove_tracker(tracker);
	}
}

void WebXRInterfaceJS::_on_controller_changed() {
	// Register "virtual" gamepads with Godot for the ones we get from WebXR.
	godot_webxr_sample_controller_data();
	for (int i = 0; i < 2; i++) {
		bool controller_connected = godot_webxr_is_controller_connected(i);
		if (controllers_state[i] != controller_connected) {
			Input::get_singleton()->joy_connection_changed(i + 100, controller_connected, i == 0 ? "Left" : "Right", "");
			controllers_state[i] = controller_connected;
		}
	}
}

void WebXRInterfaceJS::_on_input_event(int p_event_type, int p_input_source) {
	if (p_event_type == WEBXR_INPUT_EVENT_SELECTSTART || p_event_type == WEBXR_INPUT_EVENT_SELECTEND) {
		int target_ray_mode = godot_webxr_get_controller_target_ray_mode(p_input_source);
		if (target_ray_mode == WebXRInterface::TARGET_RAY_MODE_SCREEN) {
			int touch_index = _get_touch_index(p_input_source);
			if (touch_index < 5) {
				touching[touch_index] = (p_event_type == WEBXR_INPUT_EVENT_SELECTSTART);
			}

			int *axes = godot_webxr_get_controller_axes(p_input_source, false);
			if (axes) {
				Vector2 joy_vector = _get_joy_vector_from_axes(axes);
				Vector2 position = _get_screen_position_from_joy_vector(joy_vector);
				free(axes);

				InputDefault *input = (InputDefault *)Input::get_singleton();

				int joy_id = p_input_source + 100;
				input->set_joy_axis(joy_id, 0, joy_vector.x);
				input->set_joy_axis(joy_id, 1, joy_vector.y);

				Ref<InputEventScreenTouch> event;
				event.instance();
				event->set_index(touch_index);
				event->set_position(position);
				event->set_pressed(p_event_type == WEBXR_INPUT_EVENT_SELECTSTART);
				Input::get_singleton()->parse_input_event(event);
			}
		}
	}

	int controller_id = p_input_source + 1;
	switch (p_event_type) {
		case WEBXR_INPUT_EVENT_SELECTSTART:
			emit_signal("selectstart", controller_id);
			break;

		case WEBXR_INPUT_EVENT_SELECTEND:
			emit_signal("selectend", controller_id);
			break;

		case WEBXR_INPUT_EVENT_SELECT:
			emit_signal("select", controller_id);
			break;

		case WEBXR_INPUT_EVENT_SQUEEZESTART:
			emit_signal("squeezestart", controller_id);
			break;

		case WEBXR_INPUT_EVENT_SQUEEZEEND:
			emit_signal("squeezeend", controller_id);
			break;

		case WEBXR_INPUT_EVENT_SQUEEZE:
			emit_signal("squeeze", controller_id);
			break;
	}
}

int WebXRInterfaceJS::_get_touch_index(int p_input_source) {
	int index = 0;
	for (int i = 0; i < p_input_source; i++) {
		if (godot_webxr_get_controller_target_ray_mode(i) == WebXRInterface::TARGET_RAY_MODE_SCREEN) {
			index++;
		}
	}
	return index;
}

Vector2 WebXRInterfaceJS::_get_joy_vector_from_axes(int *p_axes) {
	float x_axis = 0.0;
	float y_axis = 0.0;

	if (p_axes[0] >= 2) {
		x_axis = *((float *)p_axes + 1);
		y_axis = *((float *)p_axes + 2);
	}

	return Vector2(x_axis, y_axis);
}

Vector2 WebXRInterfaceJS::_get_screen_position_from_joy_vector(const Vector2 &p_joy_vector) {
	Vector2 position_percentage((p_joy_vector.x + 1.0f) / 2.0f, ((p_joy_vector.y) + 1.0f) / 2.0f);
	Vector2 position = get_render_targetsize() * position_percentage;

	return position;
}

void WebXRInterfaceJS::notification(int p_what) {
	// Nothing to do here.
}

WebXRInterfaceJS::WebXRInterfaceJS() {
	initialized = false;
	xr_standard_mapping = false;
	session_mode = "inline";
	requested_reference_space_types = "local";
};

WebXRInterfaceJS::~WebXRInterfaceJS() {
	// and make sure we cleanup if we haven't already
	if (initialized) {
		uninitialize();
	};
};

#endif // JAVASCRIPT_ENABLED