webxr_interface_js.cpp 29 KB

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