webxr_interface_js.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832
  1. /**************************************************************************/
  2. /* webxr_interface_js.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  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 "webxr_interface_js.h"
  31. #ifdef WEB_ENABLED
  32. #include "godot_webxr.h"
  33. #include "core/input/input.h"
  34. #include "core/os/os.h"
  35. #include "drivers/gles3/storage/texture_storage.h"
  36. #include "scene/main/scene_tree.h"
  37. #include "scene/main/window.h"
  38. #include "servers/rendering/renderer_compositor.h"
  39. #include "servers/rendering/rendering_server_globals.h"
  40. #include "servers/xr/xr_hand_tracker.h"
  41. #include <emscripten.h>
  42. #include <stdlib.h>
  43. void _emwebxr_on_session_supported(char *p_session_mode, int p_supported) {
  44. XRServer *xr_server = XRServer::get_singleton();
  45. ERR_FAIL_NULL(xr_server);
  46. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  47. ERR_FAIL_COND(interface.is_null());
  48. String session_mode = String(p_session_mode);
  49. interface->emit_signal(SNAME("session_supported"), session_mode, p_supported ? true : false);
  50. }
  51. void _emwebxr_on_session_started(char *p_reference_space_type, char *p_enabled_features) {
  52. XRServer *xr_server = XRServer::get_singleton();
  53. ERR_FAIL_NULL(xr_server);
  54. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  55. ERR_FAIL_COND(interface.is_null());
  56. String reference_space_type = String(p_reference_space_type);
  57. interface->_set_reference_space_type(reference_space_type);
  58. interface->_set_enabled_features(p_enabled_features);
  59. interface->emit_signal(SNAME("session_started"));
  60. }
  61. void _emwebxr_on_session_ended() {
  62. XRServer *xr_server = XRServer::get_singleton();
  63. ERR_FAIL_NULL(xr_server);
  64. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  65. ERR_FAIL_COND(interface.is_null());
  66. interface->uninitialize();
  67. interface->emit_signal(SNAME("session_ended"));
  68. }
  69. void _emwebxr_on_session_failed(char *p_message) {
  70. XRServer *xr_server = XRServer::get_singleton();
  71. ERR_FAIL_NULL(xr_server);
  72. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  73. ERR_FAIL_COND(interface.is_null());
  74. interface->uninitialize();
  75. String message = String(p_message);
  76. interface->emit_signal(SNAME("session_failed"), message);
  77. }
  78. extern "C" EMSCRIPTEN_KEEPALIVE void _emwebxr_on_input_event(int p_event_type, int p_input_source_id) {
  79. XRServer *xr_server = XRServer::get_singleton();
  80. ERR_FAIL_NULL(xr_server);
  81. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  82. ERR_FAIL_COND(interface.is_null());
  83. interface->_on_input_event(p_event_type, p_input_source_id);
  84. }
  85. extern "C" EMSCRIPTEN_KEEPALIVE void _emwebxr_on_simple_event(char *p_signal_name) {
  86. XRServer *xr_server = XRServer::get_singleton();
  87. ERR_FAIL_NULL(xr_server);
  88. Ref<WebXRInterfaceJS> interface = xr_server->find_interface("WebXR");
  89. ERR_FAIL_COND(interface.is_null());
  90. StringName signal_name = StringName(p_signal_name);
  91. interface->emit_signal(signal_name);
  92. }
  93. void WebXRInterfaceJS::is_session_supported(const String &p_session_mode) {
  94. godot_webxr_is_session_supported(p_session_mode.utf8().get_data(), &_emwebxr_on_session_supported);
  95. }
  96. void WebXRInterfaceJS::set_session_mode(String p_session_mode) {
  97. session_mode = p_session_mode;
  98. }
  99. String WebXRInterfaceJS::get_session_mode() const {
  100. return session_mode;
  101. }
  102. void WebXRInterfaceJS::set_required_features(String p_required_features) {
  103. required_features = p_required_features;
  104. }
  105. String WebXRInterfaceJS::get_required_features() const {
  106. return required_features;
  107. }
  108. void WebXRInterfaceJS::set_optional_features(String p_optional_features) {
  109. optional_features = p_optional_features;
  110. }
  111. String WebXRInterfaceJS::get_optional_features() const {
  112. return optional_features;
  113. }
  114. void WebXRInterfaceJS::set_requested_reference_space_types(String p_requested_reference_space_types) {
  115. requested_reference_space_types = p_requested_reference_space_types;
  116. }
  117. String WebXRInterfaceJS::get_requested_reference_space_types() const {
  118. return requested_reference_space_types;
  119. }
  120. String WebXRInterfaceJS::get_reference_space_type() const {
  121. return reference_space_type;
  122. }
  123. String WebXRInterfaceJS::get_enabled_features() const {
  124. return enabled_features;
  125. }
  126. bool WebXRInterfaceJS::is_input_source_active(int p_input_source_id) const {
  127. ERR_FAIL_INDEX_V(p_input_source_id, input_source_count, false);
  128. return input_sources[p_input_source_id].active;
  129. }
  130. Ref<XRPositionalTracker> WebXRInterfaceJS::get_input_source_tracker(int p_input_source_id) const {
  131. ERR_FAIL_INDEX_V(p_input_source_id, input_source_count, Ref<XRPositionalTracker>());
  132. return input_sources[p_input_source_id].tracker;
  133. }
  134. WebXRInterface::TargetRayMode WebXRInterfaceJS::get_input_source_target_ray_mode(int p_input_source_id) const {
  135. ERR_FAIL_INDEX_V(p_input_source_id, input_source_count, WebXRInterface::TARGET_RAY_MODE_UNKNOWN);
  136. if (!input_sources[p_input_source_id].active) {
  137. return WebXRInterface::TARGET_RAY_MODE_UNKNOWN;
  138. }
  139. return input_sources[p_input_source_id].target_ray_mode;
  140. }
  141. String WebXRInterfaceJS::get_visibility_state() const {
  142. char *c_str = godot_webxr_get_visibility_state();
  143. if (c_str) {
  144. String visibility_state = String(c_str);
  145. free(c_str);
  146. return visibility_state;
  147. }
  148. return String();
  149. }
  150. PackedVector3Array WebXRInterfaceJS::get_play_area() const {
  151. PackedVector3Array ret;
  152. float *points;
  153. int point_count = godot_webxr_get_bounds_geometry(&points);
  154. if (point_count > 0) {
  155. ret.resize(point_count);
  156. for (int i = 0; i < point_count; i++) {
  157. float *js_vector3 = points + (i * 3);
  158. ret.set(i, Vector3(js_vector3[0], js_vector3[1], js_vector3[2]));
  159. }
  160. free(points);
  161. }
  162. return ret;
  163. }
  164. float WebXRInterfaceJS::get_display_refresh_rate() const {
  165. return godot_webxr_get_frame_rate();
  166. }
  167. void WebXRInterfaceJS::set_display_refresh_rate(float p_refresh_rate) {
  168. godot_webxr_update_target_frame_rate(p_refresh_rate);
  169. }
  170. Array WebXRInterfaceJS::get_available_display_refresh_rates() const {
  171. Array ret;
  172. float *rates;
  173. int rate_count = godot_webxr_get_supported_frame_rates(&rates);
  174. if (rate_count > 0) {
  175. ret.resize(rate_count);
  176. for (int i = 0; i < rate_count; i++) {
  177. ret[i] = rates[i];
  178. }
  179. free(rates);
  180. }
  181. return ret;
  182. }
  183. StringName WebXRInterfaceJS::get_name() const {
  184. return "WebXR";
  185. };
  186. uint32_t WebXRInterfaceJS::get_capabilities() const {
  187. return XRInterface::XR_STEREO | XRInterface::XR_MONO | XRInterface::XR_VR | XRInterface::XR_AR;
  188. };
  189. uint32_t WebXRInterfaceJS::get_view_count() {
  190. return godot_webxr_get_view_count();
  191. };
  192. bool WebXRInterfaceJS::is_initialized() const {
  193. return (initialized);
  194. };
  195. bool WebXRInterfaceJS::initialize() {
  196. XRServer *xr_server = XRServer::get_singleton();
  197. ERR_FAIL_NULL_V(xr_server, false);
  198. if (!initialized) {
  199. if (!godot_webxr_is_supported()) {
  200. return false;
  201. }
  202. if (requested_reference_space_types.size() == 0) {
  203. return false;
  204. }
  205. enabled_features.clear();
  206. // We must create a tracker for our head.
  207. head_transform.basis = Basis();
  208. head_transform.origin = Vector3();
  209. head_tracker.instantiate();
  210. head_tracker->set_tracker_type(XRServer::TRACKER_HEAD);
  211. head_tracker->set_tracker_name("head");
  212. head_tracker->set_tracker_desc("Players head");
  213. xr_server->add_tracker(head_tracker);
  214. // Make this our primary interface.
  215. xr_server->set_primary_interface(this);
  216. // Clear render_targetsize to make sure it gets reset to the new size.
  217. // Clearing in uninitialize() doesn't work because a frame can still be
  218. // rendered after it's called, which will fill render_targetsize again.
  219. render_targetsize.width = 0;
  220. render_targetsize.height = 0;
  221. initialized = true;
  222. godot_webxr_initialize(
  223. session_mode.utf8().get_data(),
  224. required_features.utf8().get_data(),
  225. optional_features.utf8().get_data(),
  226. requested_reference_space_types.utf8().get_data(),
  227. &_emwebxr_on_session_started,
  228. &_emwebxr_on_session_ended,
  229. &_emwebxr_on_session_failed,
  230. &_emwebxr_on_input_event,
  231. &_emwebxr_on_simple_event);
  232. };
  233. return true;
  234. };
  235. void WebXRInterfaceJS::uninitialize() {
  236. if (initialized) {
  237. XRServer *xr_server = XRServer::get_singleton();
  238. if (xr_server != nullptr) {
  239. if (head_tracker.is_valid()) {
  240. xr_server->remove_tracker(head_tracker);
  241. head_tracker.unref();
  242. }
  243. for (int i = 0; i < HAND_MAX; i++) {
  244. if (hand_trackers[i].is_valid()) {
  245. xr_server->remove_hand_tracker(i == 0 ? "/user/left" : "/user/right");
  246. hand_trackers[i].unref();
  247. }
  248. }
  249. if (xr_server->get_primary_interface() == this) {
  250. // no longer our primary interface
  251. xr_server->set_primary_interface(nullptr);
  252. }
  253. }
  254. godot_webxr_uninitialize();
  255. GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
  256. if (texture_storage != nullptr) {
  257. for (KeyValue<unsigned int, RID> &E : texture_cache) {
  258. // Forcibly mark as not part of a render target so we can free it.
  259. GLES3::Texture *texture = texture_storage->get_texture(E.value);
  260. texture->is_render_target = false;
  261. texture_storage->texture_free(E.value);
  262. }
  263. }
  264. texture_cache.clear();
  265. reference_space_type.clear();
  266. enabled_features.clear();
  267. initialized = false;
  268. };
  269. };
  270. Dictionary WebXRInterfaceJS::get_system_info() {
  271. Dictionary dict;
  272. // TODO get actual information from WebXR to return here
  273. dict[SNAME("XRRuntimeName")] = String("WebXR");
  274. dict[SNAME("XRRuntimeVersion")] = String("");
  275. return dict;
  276. }
  277. Transform3D WebXRInterfaceJS::_js_matrix_to_transform(float *p_js_matrix) {
  278. Transform3D transform;
  279. transform.basis.rows[0].x = p_js_matrix[0];
  280. transform.basis.rows[1].x = p_js_matrix[1];
  281. transform.basis.rows[2].x = p_js_matrix[2];
  282. transform.basis.rows[0].y = p_js_matrix[4];
  283. transform.basis.rows[1].y = p_js_matrix[5];
  284. transform.basis.rows[2].y = p_js_matrix[6];
  285. transform.basis.rows[0].z = p_js_matrix[8];
  286. transform.basis.rows[1].z = p_js_matrix[9];
  287. transform.basis.rows[2].z = p_js_matrix[10];
  288. transform.origin.x = p_js_matrix[12];
  289. transform.origin.y = p_js_matrix[13];
  290. transform.origin.z = p_js_matrix[14];
  291. return transform;
  292. }
  293. Size2 WebXRInterfaceJS::get_render_target_size() {
  294. if (render_targetsize.width != 0 && render_targetsize.height != 0) {
  295. return render_targetsize;
  296. }
  297. int js_size[2];
  298. bool has_size = godot_webxr_get_render_target_size(js_size);
  299. if (!initialized || !has_size) {
  300. // As a temporary default (until WebXR is fully initialized), use the
  301. // window size.
  302. return DisplayServer::get_singleton()->window_get_size();
  303. }
  304. render_targetsize.width = (float)js_size[0];
  305. render_targetsize.height = (float)js_size[1];
  306. return render_targetsize;
  307. };
  308. Transform3D WebXRInterfaceJS::get_camera_transform() {
  309. Transform3D camera_transform;
  310. XRServer *xr_server = XRServer::get_singleton();
  311. ERR_FAIL_NULL_V(xr_server, camera_transform);
  312. if (initialized) {
  313. double world_scale = xr_server->get_world_scale();
  314. Transform3D _head_transform = head_transform;
  315. _head_transform.origin *= world_scale;
  316. camera_transform = (xr_server->get_reference_frame()) * _head_transform;
  317. }
  318. return camera_transform;
  319. };
  320. Transform3D WebXRInterfaceJS::get_transform_for_view(uint32_t p_view, const Transform3D &p_cam_transform) {
  321. XRServer *xr_server = XRServer::get_singleton();
  322. ERR_FAIL_NULL_V(xr_server, p_cam_transform);
  323. ERR_FAIL_COND_V(!initialized, p_cam_transform);
  324. float js_matrix[16];
  325. bool has_transform = godot_webxr_get_transform_for_view(p_view, js_matrix);
  326. if (!has_transform) {
  327. return p_cam_transform;
  328. }
  329. Transform3D transform_for_view = _js_matrix_to_transform(js_matrix);
  330. double world_scale = xr_server->get_world_scale();
  331. transform_for_view.origin *= world_scale;
  332. return p_cam_transform * xr_server->get_reference_frame() * transform_for_view;
  333. };
  334. Projection WebXRInterfaceJS::get_projection_for_view(uint32_t p_view, double p_aspect, double p_z_near, double p_z_far) {
  335. Projection view;
  336. ERR_FAIL_COND_V(!initialized, view);
  337. float js_matrix[16];
  338. bool has_projection = godot_webxr_get_projection_for_view(p_view, js_matrix);
  339. if (!has_projection) {
  340. return view;
  341. }
  342. int k = 0;
  343. for (int i = 0; i < 4; i++) {
  344. for (int j = 0; j < 4; j++) {
  345. view.columns[i][j] = js_matrix[k++];
  346. }
  347. }
  348. // Copied from godot_oculus_mobile's ovr_mobile_session.cpp
  349. view.columns[2][2] = -(p_z_far + p_z_near) / (p_z_far - p_z_near);
  350. view.columns[3][2] = -(2.0f * p_z_far * p_z_near) / (p_z_far - p_z_near);
  351. return view;
  352. }
  353. bool WebXRInterfaceJS::pre_draw_viewport(RID p_render_target) {
  354. GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
  355. if (texture_storage == nullptr) {
  356. return false;
  357. }
  358. // Cache the resources so we don't have to get them from JS twice.
  359. color_texture = _get_color_texture();
  360. depth_texture = _get_depth_texture();
  361. // Per the WebXR spec, it returns "opaque textures" to us, which may be the
  362. // same WebGLTexture object (which would be the same GLuint in C++) but
  363. // represent a different underlying resource (probably the next texture in
  364. // the XR device's swap chain). In order to render to this texture, we need
  365. // to re-attach it to the FBO, otherwise we get an "incomplete FBO" error.
  366. //
  367. // See: https://immersive-web.github.io/layers/#xropaquetextures
  368. //
  369. // So, even if the color and depth textures have the same GLuint as the last
  370. // frame, we need to re-attach them again.
  371. texture_storage->render_target_set_reattach_textures(p_render_target, true);
  372. return true;
  373. }
  374. Vector<BlitToScreen> WebXRInterfaceJS::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
  375. Vector<BlitToScreen> blit_to_screen;
  376. GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
  377. if (texture_storage == nullptr) {
  378. return blit_to_screen;
  379. }
  380. texture_storage->render_target_set_reattach_textures(p_render_target, false);
  381. return blit_to_screen;
  382. };
  383. RID WebXRInterfaceJS::_get_color_texture() {
  384. unsigned int texture_id = godot_webxr_get_color_texture();
  385. if (texture_id == 0) {
  386. return RID();
  387. }
  388. return _get_texture(texture_id);
  389. }
  390. RID WebXRInterfaceJS::_get_depth_texture() {
  391. unsigned int texture_id = godot_webxr_get_depth_texture();
  392. if (texture_id == 0) {
  393. return RID();
  394. }
  395. return _get_texture(texture_id);
  396. }
  397. RID WebXRInterfaceJS::_get_texture(unsigned int p_texture_id) {
  398. RBMap<unsigned int, RID>::Element *cache = texture_cache.find(p_texture_id);
  399. if (cache != nullptr) {
  400. return cache->get();
  401. }
  402. GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
  403. if (texture_storage == nullptr) {
  404. return RID();
  405. }
  406. uint32_t view_count = godot_webxr_get_view_count();
  407. Size2 texture_size = get_render_target_size();
  408. RID texture = texture_storage->texture_create_external(
  409. view_count == 1 ? GLES3::Texture::TYPE_2D : GLES3::Texture::TYPE_LAYERED,
  410. Image::FORMAT_RGBA8,
  411. p_texture_id,
  412. (int)texture_size.width,
  413. (int)texture_size.height,
  414. 1,
  415. view_count);
  416. texture_cache.insert(p_texture_id, texture);
  417. return texture;
  418. }
  419. RID WebXRInterfaceJS::get_color_texture() {
  420. return color_texture;
  421. }
  422. RID WebXRInterfaceJS::get_depth_texture() {
  423. return depth_texture;
  424. }
  425. RID WebXRInterfaceJS::get_velocity_texture() {
  426. unsigned int texture_id = godot_webxr_get_velocity_texture();
  427. if (texture_id == 0) {
  428. return RID();
  429. }
  430. return _get_texture(texture_id);
  431. }
  432. void WebXRInterfaceJS::process() {
  433. if (initialized) {
  434. // Get the "head" position.
  435. float js_matrix[16];
  436. if (godot_webxr_get_transform_for_view(-1, js_matrix)) {
  437. head_transform = _js_matrix_to_transform(js_matrix);
  438. }
  439. if (head_tracker.is_valid()) {
  440. head_tracker->set_pose("default", head_transform, Vector3(), Vector3());
  441. }
  442. // Update all input sources.
  443. for (int i = 0; i < input_source_count; i++) {
  444. _update_input_source(i);
  445. }
  446. };
  447. };
  448. void WebXRInterfaceJS::_update_input_source(int p_input_source_id) {
  449. XRServer *xr_server = XRServer::get_singleton();
  450. ERR_FAIL_NULL(xr_server);
  451. InputSource &input_source = input_sources[p_input_source_id];
  452. float target_pose[16];
  453. int tmp_target_ray_mode;
  454. int touch_index;
  455. int has_grip_pose;
  456. float grip_pose[16];
  457. int has_standard_mapping;
  458. int button_count;
  459. float buttons[10];
  460. int axes_count;
  461. float axes[10];
  462. int has_hand_data;
  463. float hand_joints[WEBXR_HAND_JOINT_MAX * 16];
  464. float hand_radii[WEBXR_HAND_JOINT_MAX];
  465. input_source.active = godot_webxr_update_input_source(
  466. p_input_source_id,
  467. target_pose,
  468. &tmp_target_ray_mode,
  469. &touch_index,
  470. &has_grip_pose,
  471. grip_pose,
  472. &has_standard_mapping,
  473. &button_count,
  474. buttons,
  475. &axes_count,
  476. axes,
  477. &has_hand_data,
  478. hand_joints,
  479. hand_radii);
  480. if (!input_source.active) {
  481. if (input_source.tracker.is_valid()) {
  482. xr_server->remove_tracker(input_source.tracker);
  483. input_source.tracker.unref();
  484. }
  485. return;
  486. }
  487. input_source.target_ray_mode = (WebXRInterface::TargetRayMode)tmp_target_ray_mode;
  488. input_source.touch_index = touch_index;
  489. Ref<XRPositionalTracker> &tracker = input_source.tracker;
  490. if (tracker.is_null()) {
  491. tracker.instantiate();
  492. StringName tracker_name;
  493. if (input_source.target_ray_mode == WebXRInterface::TargetRayMode::TARGET_RAY_MODE_SCREEN) {
  494. tracker_name = touch_names[touch_index];
  495. } else {
  496. tracker_name = tracker_names[p_input_source_id];
  497. }
  498. // Input source id's 0 and 1 are always the left and right hands.
  499. if (p_input_source_id < 2) {
  500. tracker->set_tracker_type(XRServer::TRACKER_CONTROLLER);
  501. tracker->set_tracker_name(tracker_name);
  502. tracker->set_tracker_desc(p_input_source_id == 0 ? "Left hand controller" : "Right hand controller");
  503. tracker->set_tracker_hand(p_input_source_id == 0 ? XRPositionalTracker::TRACKER_HAND_LEFT : XRPositionalTracker::TRACKER_HAND_RIGHT);
  504. } else {
  505. tracker->set_tracker_name(tracker_name);
  506. tracker->set_tracker_desc(tracker_name);
  507. }
  508. xr_server->add_tracker(tracker);
  509. }
  510. Transform3D aim_transform = _js_matrix_to_transform(target_pose);
  511. tracker->set_pose(SNAME("default"), aim_transform, Vector3(), Vector3());
  512. tracker->set_pose(SNAME("aim"), aim_transform, Vector3(), Vector3());
  513. if (has_grip_pose) {
  514. tracker->set_pose(SNAME("grip"), _js_matrix_to_transform(grip_pose), Vector3(), Vector3());
  515. }
  516. for (int i = 0; i < button_count; i++) {
  517. StringName button_name = has_standard_mapping ? standard_button_names[i] : unknown_button_names[i];
  518. StringName button_pressure_name = has_standard_mapping ? standard_button_pressure_names[i] : unknown_button_pressure_names[i];
  519. float value = buttons[i];
  520. bool state = value > 0.0;
  521. tracker->set_input(button_name, state);
  522. tracker->set_input(button_pressure_name, value);
  523. }
  524. for (int i = 0; i < axes_count; i++) {
  525. StringName axis_name = has_standard_mapping ? standard_axis_names[i] : unknown_axis_names[i];
  526. float value = axes[i];
  527. if (has_standard_mapping && (i == 1 || i == 3)) {
  528. // Invert the Y-axis on thumbsticks and trackpads, in order to
  529. // match OpenXR and other XR platform SDKs.
  530. value = -value;
  531. }
  532. tracker->set_input(axis_name, value);
  533. }
  534. // Also create Vector2's for the thumbstick and trackpad when we have the
  535. // standard mapping.
  536. if (has_standard_mapping) {
  537. if (axes_count >= 2) {
  538. tracker->set_input(standard_vector_names[0], Vector2(axes[0], -axes[1]));
  539. }
  540. if (axes_count >= 4) {
  541. tracker->set_input(standard_vector_names[1], Vector2(axes[2], -axes[3]));
  542. }
  543. }
  544. if (input_source.target_ray_mode == WebXRInterface::TARGET_RAY_MODE_SCREEN) {
  545. if (touch_index < 5 && axes_count >= 2) {
  546. Vector2 joy_vector = Vector2(axes[0], axes[1]);
  547. Vector2 position = _get_screen_position_from_joy_vector(joy_vector);
  548. if (touches[touch_index].is_touching) {
  549. Vector2 delta = position - touches[touch_index].position;
  550. // If position has changed by at least 1 pixel, generate a drag event.
  551. if (abs(delta.x) >= 1.0 || abs(delta.y) >= 1.0) {
  552. Ref<InputEventScreenDrag> event;
  553. event.instantiate();
  554. event->set_index(touch_index);
  555. event->set_position(position);
  556. event->set_relative(delta);
  557. event->set_relative_screen_position(delta);
  558. Input::get_singleton()->parse_input_event(event);
  559. }
  560. }
  561. touches[touch_index].position = position;
  562. }
  563. }
  564. if (p_input_source_id < 2) {
  565. Ref<XRHandTracker> hand_tracker = hand_trackers[p_input_source_id];
  566. if (has_hand_data) {
  567. // Transform orientations to match Godot Humanoid skeleton.
  568. const Basis bone_adjustment(
  569. Vector3(-1.0, 0.0, 0.0),
  570. Vector3(0.0, 0.0, -1.0),
  571. Vector3(0.0, -1.0, 0.0));
  572. if (unlikely(hand_tracker.is_null())) {
  573. hand_tracker.instantiate();
  574. hand_tracker->set_hand(p_input_source_id == 0 ? XRHandTracker::HAND_LEFT : XRHandTracker::HAND_RIGHT);
  575. // These flags always apply, since WebXR doesn't give us enough insight to be more fine grained.
  576. BitField<XRHandTracker::HandJointFlags> joint_flags(XRHandTracker::HAND_JOINT_FLAG_POSITION_VALID | XRHandTracker::HAND_JOINT_FLAG_ORIENTATION_VALID | XRHandTracker::HAND_JOINT_FLAG_POSITION_TRACKED | XRHandTracker::HAND_JOINT_FLAG_ORIENTATION_TRACKED);
  577. for (int godot_joint = 0; godot_joint < XRHandTracker::HAND_JOINT_MAX; godot_joint++) {
  578. hand_tracker->set_hand_joint_flags((XRHandTracker::HandJoint)godot_joint, joint_flags);
  579. }
  580. hand_trackers[p_input_source_id] = hand_tracker;
  581. xr_server->add_hand_tracker(p_input_source_id == 0 ? "/user/left" : "/user/right", hand_tracker);
  582. }
  583. hand_tracker->set_has_tracking_data(true);
  584. for (int webxr_joint = 0; webxr_joint < WEBXR_HAND_JOINT_MAX; webxr_joint++) {
  585. XRHandTracker::HandJoint godot_joint = (XRHandTracker::HandJoint)(webxr_joint + 1);
  586. Transform3D joint_transform = _js_matrix_to_transform(hand_joints + (16 * webxr_joint));
  587. joint_transform.basis *= bone_adjustment;
  588. hand_tracker->set_hand_joint_transform(godot_joint, joint_transform);
  589. hand_tracker->set_hand_joint_radius(godot_joint, hand_radii[webxr_joint]);
  590. }
  591. // WebXR doesn't have a palm joint, so we calculate it by finding the middle of the middle finger metacarpal bone.
  592. {
  593. // 10 is the WebXR middle finger metacarpal joint, and 12 is the offset to the transform origin.
  594. const float *start_pos = hand_joints + (10 * 16) + 12;
  595. // 11 is the WebXR middle finger phalanx proximal joint, and 12 is the offset to the transform origin.
  596. const float *end_pos = hand_joints + (11 * 16) + 12;
  597. Transform3D palm_transform;
  598. palm_transform.origin = (Vector3(start_pos[0], start_pos[1], start_pos[2]) + Vector3(end_pos[0], end_pos[1], end_pos[2])) / 2.0;
  599. hand_tracker->set_hand_joint_transform(XRHandTracker::HAND_JOINT_PALM, palm_transform);
  600. }
  601. } else if (hand_tracker.is_valid()) {
  602. hand_tracker->set_has_tracking_data(false);
  603. }
  604. }
  605. }
  606. void WebXRInterfaceJS::_on_input_event(int p_event_type, int p_input_source_id) {
  607. // Get the latest data for this input source. For transient input sources,
  608. // we may not have any data at all yet!
  609. _update_input_source(p_input_source_id);
  610. if (p_event_type == WEBXR_INPUT_EVENT_SELECTSTART || p_event_type == WEBXR_INPUT_EVENT_SELECTEND) {
  611. const InputSource &input_source = input_sources[p_input_source_id];
  612. if (input_source.target_ray_mode == WebXRInterface::TARGET_RAY_MODE_SCREEN) {
  613. int touch_index = input_source.touch_index;
  614. if (touch_index >= 0 && touch_index < 5) {
  615. touches[touch_index].is_touching = (p_event_type == WEBXR_INPUT_EVENT_SELECTSTART);
  616. Ref<InputEventScreenTouch> event;
  617. event.instantiate();
  618. event->set_index(touch_index);
  619. event->set_position(touches[touch_index].position);
  620. event->set_pressed(p_event_type == WEBXR_INPUT_EVENT_SELECTSTART);
  621. Input::get_singleton()->parse_input_event(event);
  622. }
  623. }
  624. }
  625. switch (p_event_type) {
  626. case WEBXR_INPUT_EVENT_SELECTSTART:
  627. emit_signal("selectstart", p_input_source_id);
  628. break;
  629. case WEBXR_INPUT_EVENT_SELECTEND:
  630. emit_signal("selectend", p_input_source_id);
  631. // Emit the 'select' event on our own (rather than intercepting the
  632. // one from JavaScript) so that we don't have to needlessly call
  633. // _update_input_source() a second time.
  634. emit_signal("select", p_input_source_id);
  635. break;
  636. case WEBXR_INPUT_EVENT_SQUEEZESTART:
  637. emit_signal("squeezestart", p_input_source_id);
  638. break;
  639. case WEBXR_INPUT_EVENT_SQUEEZEEND:
  640. emit_signal("squeezeend", p_input_source_id);
  641. // Again, we emit the 'squeeze' event on our own to avoid extra work.
  642. emit_signal("squeeze", p_input_source_id);
  643. break;
  644. }
  645. }
  646. Vector2 WebXRInterfaceJS::_get_screen_position_from_joy_vector(const Vector2 &p_joy_vector) {
  647. SceneTree *scene_tree = Object::cast_to<SceneTree>(OS::get_singleton()->get_main_loop());
  648. if (!scene_tree) {
  649. return Vector2();
  650. }
  651. Window *viewport = scene_tree->get_root();
  652. Vector2 position_percentage((p_joy_vector.x + 1.0f) / 2.0f, ((p_joy_vector.y) + 1.0f) / 2.0f);
  653. Vector2 position = (Size2)viewport->get_size() * position_percentage;
  654. return position;
  655. }
  656. WebXRInterfaceJS::WebXRInterfaceJS() {
  657. initialized = false;
  658. session_mode = "inline";
  659. requested_reference_space_types = "local";
  660. };
  661. WebXRInterfaceJS::~WebXRInterfaceJS() {
  662. // and make sure we cleanup if we haven't already
  663. if (initialized) {
  664. uninitialize();
  665. };
  666. };
  667. #endif // WEB_ENABLED