matrixfurry.com / monado
The open source OpenXR runtime
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

xrt: Adds support for XR_HTC_facial_tracking xrt-devices

Korcan Hussein 50f3816c 1a6c444a

+433 -16
+5 -1
CMakeLists.txt
··· 1 - # Copyright 2018-2023, Collabora, Ltd. 1 + # Copyright 2018-2024, Collabora, Ltd. 2 2 # SPDX-License-Identifier: BSL-1.0 3 3 4 4 cmake_minimum_required(VERSION 3.10.2) ··· 364 364 XRT_FEATURE_OPENXR_VULKAN_SWAPCHAIN_FORMAT_LIST 365 365 "Enable support for the XR_KHR_vulkan_swapchain_format_list extension" ON 366 366 ) 367 + if(NOT DEFINED XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC) 368 + set(XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC OFF) 369 + endif() 367 370 368 371 # Interaction extension support. 369 372 if(NOT DEFINED XRT_FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE) ··· 618 621 message(STATUS "# FEATURE_OPENXR: ${XRT_FEATURE_OPENXR}") 619 622 message(STATUS "# FEATURE_OPENXR_DEBUG_UTILS: ${XRT_FEATURE_OPENXR_DEBUG_UTILS}") 620 623 message(STATUS "# FEATURE_OPENXR_DISPLAY_REFRESH_RATE: ${XRT_FEATURE_OPENXR_DISPLAY_REFRESH_RATE}") 624 + message(STATUS "# FEATURE_OPENXR_FACIAL_TRACKING_HTC: ${XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC}") 621 625 message(STATUS "# FEATURE_OPENXR_FORCE_FEEDBACK_CURL: ${XRT_FEATURE_OPENXR_FORCE_FEEDBACK_CURL}") 622 626 message(STATUS "# FEATURE_OPENXR_HEADLESS: ${XRT_FEATURE_OPENXR_HEADLESS}") 623 627 message(STATUS "# FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE: ${XRT_FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE}")
+1
scripts/generate_oxr_ext_support.py
··· 84 84 ['XR_MNDX_force_feedback_curl', 'XRT_FEATURE_OPENXR_FORCE_FEEDBACK_CURL'], 85 85 ['XR_MNDX_hydra', 'XRT_FEATURE_OPENXR_INTERACTION_MNDX'], 86 86 ['XR_MNDX_system_buttons', 'XRT_FEATURE_OPENXR_INTERACTION_MNDX'], 87 + ['XR_HTC_facial_tracking', 'XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC'], 87 88 ) 88 89 89 90
+7
scripts/mapping.imp
··· 34 34 { symbol: ["XRT_FEATURE_OPENXR_DEBUG_UTILS", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 35 35 { symbol: ["XRT_FEATURE_OPENXR_DISPLAY_REFRESH_RATE", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 36 36 { symbol: ["XRT_FEATURE_OPENXR_FORCE_FEEDBACK_CURL", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 37 + { symbol: ["XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 37 38 { symbol: ["XRT_FEATURE_OPENXR_HEADLESS", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 38 39 { symbol: ["XRT_FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 39 40 { symbol: ["XRT_FEATURE_OPENXR_INTERACTION_EXT_HAND", "public", "\"xrt/xrt_config_build.h\"", "public"] }, ··· 43 44 { symbol: ["XRT_FEATURE_OPENXR_INTERACTION_MSFT_HAND", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 44 45 { symbol: ["XRT_FEATURE_OPENXR_INTERACTION_OPPO", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 45 46 { symbol: ["XRT_FEATURE_OPENXR_INTERACTION_WINMR", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 47 + { symbol: ["XRT_FEATURE_OPENXR_LAYER_COLOR_SCALE_BIAS", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 46 48 { symbol: ["XRT_FEATURE_OPENXR_LAYER_CUBE", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 47 49 { symbol: ["XRT_FEATURE_OPENXR_LAYER_CYLINDER", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 48 50 { symbol: ["XRT_FEATURE_OPENXR_LAYER_DEPTH", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 49 51 { symbol: ["XRT_FEATURE_OPENXR_LAYER_EQUIRECT1", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 50 52 { symbol: ["XRT_FEATURE_OPENXR_LAYER_EQUIRECT2", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 53 + { symbol: ["XRT_FEATURE_OPENXR_LAYER_FB_ALPHA_BLEND", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 54 + { symbol: ["XRT_FEATURE_OPENXR_LAYER_FB_IMAGE_LAYOUT", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 55 + { symbol: ["XRT_FEATURE_OPENXR_LAYER_FB_SETTINGS", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 56 + { symbol: ["XRT_FEATURE_OPENXR_LAYER_FB_DEPTH_TEST", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 51 57 { symbol: ["XRT_FEATURE_OPENXR_OVERLAY", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 52 58 { symbol: ["XRT_FEATURE_OPENXR_SPACE_LOCAL_FLOOR", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 53 59 { symbol: ["XRT_FEATURE_OPENXR_SPACE_UNBOUNDED", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 54 60 { symbol: ["XRT_FEATURE_OPENXR_VISIBILITY_MASK", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 61 + { symbol: ["XRT_FEATURE_OPENXR_VULKAN_SWAPCHAIN_FORMAT_LIST", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 55 62 { symbol: ["XRT_FEATURE_RENDERDOC", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 56 63 { symbol: ["XRT_FEATURE_SERVICE", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 57 64 { symbol: ["XRT_FEATURE_SERVICE_SYSTEMD", "public", "\"xrt/xrt_config_build.h\"", "public"] },
+2 -1
src/xrt/compositor/multi/comp_multi_system.c
··· 1 - // Copyright 2019-2023, Collabora, Ltd. 1 + // Copyright 2019-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 375 375 .ext_hand_tracking_enabled = false, 376 376 .ext_eye_gaze_interaction_enabled = false, 377 377 .ext_hand_interaction_enabled = false, 378 + .htc_facial_tracking_enabled = false, 378 379 }; 379 380 380 381 switch (msc->sessions.state) {
+2 -1
src/xrt/include/xrt/xrt_compositor.h
··· 1 - // Copyright 2019-2023, Collabora, Ltd. 1 + // Copyright 2019-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 959 959 bool ext_hand_tracking_enabled; 960 960 bool ext_eye_gaze_interaction_enabled; 961 961 bool ext_hand_interaction_enabled; 962 + bool htc_facial_tracking_enabled; 962 963 }; 963 964 964 965 /*!
+3 -1
src/xrt/include/xrt/xrt_config_build.h.cmake_in
··· 1 - // Copyright 2020-2023, Collabora, Ltd. 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief What internal components we are building. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 + * @author Korcan Hussein <korcan.hussein@collabora.com> 7 8 * @ingroup xrt_iface 8 9 */ 9 10 ··· 31 32 #cmakedefine XRT_FEATURE_OPENXR_DEBUG_UTILS 32 33 #cmakedefine XRT_FEATURE_OPENXR_DISPLAY_REFRESH_RATE 33 34 #cmakedefine XRT_FEATURE_OPENXR_FORCE_FEEDBACK_CURL 35 + #cmakedefine XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC 34 36 #cmakedefine XRT_FEATURE_OPENXR_HEADLESS 35 37 #cmakedefine XRT_FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE 36 38 #cmakedefine XRT_FEATURE_OPENXR_INTERACTION_EXT_HAND
+98 -2
src/xrt/include/xrt/xrt_defines.h
··· 751 751 XRT_DEVICE_DEPTHAI, 752 752 753 753 //! XR_EXT_hand_interaction 754 - XRT_DEVICE_EXT_HAND_INTERACTION 754 + XRT_DEVICE_EXT_HAND_INTERACTION, 755 + 756 + //! XR_HTC_facial_tracking 757 + XRT_DEVICE_HTC_FACE_TRACKING 755 758 }; 756 759 757 760 /*! ··· 1119 1122 XRT_INPUT_OPPO_MR_THUMBSTICK = XRT_INPUT_NAME(0x0512, VEC2_MINUS_ONE_TO_ONE), 1120 1123 1121 1124 XRT_INPUT_GENERIC_FACE_TRACKING = XRT_INPUT_NAME(0x0600, FACE_TRACKING), 1125 + 1126 + XRT_INPUT_HTC_EYE_FACE_TRACKING = XRT_INPUT_NAME(0x0601, FACE_TRACKING), 1127 + XRT_INPUT_HTC_LIP_FACE_TRACKING = XRT_INPUT_NAME(0x0602, FACE_TRACKING), 1122 1128 // clang-format on 1123 1129 }; 1124 1130 ··· 1266 1272 1267 1273 #define XRT_OUTPUT_NAME(id, type) ((UINT32_C(id) << XRT_OUTPUT_TYPE_BITWIDTH) | (uint32_t)XRT_OUTPUT_TYPE_##type) 1268 1274 1275 + enum xrt_eye_expression_htc 1276 + { 1277 + XRT_EYE_EXPRESSION_LEFT_BLINK_HTC = 0, 1278 + XRT_EYE_EXPRESSION_LEFT_WIDE_HTC = 1, 1279 + XRT_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2, 1280 + XRT_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3, 1281 + XRT_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4, 1282 + XRT_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5, 1283 + XRT_EYE_EXPRESSION_LEFT_DOWN_HTC = 6, 1284 + XRT_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7, 1285 + XRT_EYE_EXPRESSION_LEFT_OUT_HTC = 8, 1286 + XRT_EYE_EXPRESSION_RIGHT_IN_HTC = 9, 1287 + XRT_EYE_EXPRESSION_LEFT_IN_HTC = 10, 1288 + XRT_EYE_EXPRESSION_RIGHT_OUT_HTC = 11, 1289 + XRT_EYE_EXPRESSION_LEFT_UP_HTC = 12, 1290 + XRT_EYE_EXPRESSION_RIGHT_UP_HTC = 13 1291 + }; 1292 + 1293 + enum xrt_lip_expression_htc 1294 + { 1295 + XRT_LIP_EXPRESSION_JAW_RIGHT_HTC = 0, 1296 + XRT_LIP_EXPRESSION_JAW_LEFT_HTC = 1, 1297 + XRT_LIP_EXPRESSION_JAW_FORWARD_HTC = 2, 1298 + XRT_LIP_EXPRESSION_JAW_OPEN_HTC = 3, 1299 + XRT_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4, 1300 + XRT_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5, 1301 + XRT_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6, 1302 + XRT_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7, 1303 + XRT_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8, 1304 + XRT_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9, 1305 + XRT_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10, 1306 + XRT_LIP_EXPRESSION_MOUTH_POUT_HTC = 11, 1307 + XRT_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = 12, 1308 + XRT_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = 13, 1309 + XRT_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = 14, 1310 + XRT_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = 15, 1311 + XRT_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16, 1312 + XRT_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17, 1313 + XRT_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18, 1314 + XRT_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19, 1315 + XRT_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20, 1316 + XRT_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21, 1317 + XRT_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22, 1318 + XRT_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23, 1319 + XRT_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24, 1320 + XRT_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25, 1321 + XRT_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26, 1322 + XRT_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27, 1323 + XRT_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28, 1324 + XRT_LIP_EXPRESSION_TONGUE_UP_HTC = 29, 1325 + XRT_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30, 1326 + XRT_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31, 1327 + XRT_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32, 1328 + XRT_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33, 1329 + XRT_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34, 1330 + XRT_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35, 1331 + XRT_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36 1332 + }; 1333 + 1334 + enum xrt_facial_tracking_type_htc 1335 + { 1336 + XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1, 1337 + XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC = 2 1338 + }; 1339 + 1340 + #define XRT_FACIAL_EXPRESSION_EYE_COUNT_HTC 14 1341 + #define XRT_FACIAL_EXPRESSION_LIP_COUNT_HTC 37 1342 + 1343 + struct xrt_facial_base_expression_set_htc 1344 + { 1345 + uint64_t sample_time_ns; 1346 + bool is_active; 1347 + }; 1348 + 1349 + struct xrt_facial_eye_expression_set_htc 1350 + { 1351 + struct xrt_facial_base_expression_set_htc base; 1352 + // ordered by xrt_eye_expression_htc 1353 + float expression_weights[XRT_FACIAL_EXPRESSION_EYE_COUNT_HTC]; 1354 + }; 1355 + 1356 + struct xrt_facial_lip_expression_set_htc 1357 + { 1358 + struct xrt_facial_base_expression_set_htc base; 1359 + // ordered by xrt_lip_expression_htc 1360 + float expression_weights[XRT_FACIAL_EXPRESSION_LIP_COUNT_HTC]; 1361 + }; 1362 + 1269 1363 struct xrt_facial_expression_set 1270 1364 { 1271 1365 union { 1272 - struct xrt_facial_expression_empty_set* placeholder; 1366 + struct xrt_facial_base_expression_set_htc base_expression_set_htc; 1367 + struct xrt_facial_eye_expression_set_htc eye_expression_set_htc; 1368 + struct xrt_facial_lip_expression_set_htc lip_expression_set_htc; 1273 1369 }; 1274 1370 }; 1275 1371
+2 -1
src/xrt/include/xrt/xrt_instance.h
··· 1 - // Copyright 2020-2023, Collabora, Ltd. 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 43 43 bool ext_hand_tracking_enabled; 44 44 bool ext_eye_gaze_interaction_enabled; 45 45 bool ext_hand_interaction_enabled; 46 + bool htc_facial_tracking_enabled; 46 47 }; 47 48 48 49 /*!
+4
src/xrt/ipc/server/ipc_server_handler.c
··· 200 200 EXT(ext_hand_tracking_enabled); 201 201 EXT(ext_eye_gaze_interaction_enabled); 202 202 EXT(ext_hand_interaction_enabled); 203 + #ifdef OXR_HAVE_HTC_facial_tracking 204 + EXT(htc_facial_tracking_enabled); 205 + #endif 203 206 204 207 #undef EXT 205 208 #undef PTT ··· 291 294 .ext_hand_tracking_enabled = ics->client_state.info.ext_hand_tracking_enabled, 292 295 .ext_eye_gaze_interaction_enabled = ics->client_state.info.ext_eye_gaze_interaction_enabled, 293 296 .ext_hand_interaction_enabled = ics->client_state.info.ext_hand_interaction_enabled, 297 + .htc_facial_tracking_enabled = ics->client_state.info.htc_facial_tracking_enabled, 294 298 }; 295 299 296 300 return xrt_comp_begin_session(ics->xc, &begin_session_info);
+19 -1
src/xrt/state_trackers/oxr/oxr_api_funcs.h
··· 1 - // Copyright 2018-2019, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief Header defining all API functions. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 + * @author Korcan Hussein <korcan.hussein@collabora.com> 7 8 * @ingroup oxr_api 8 9 */ 9 10 ··· 608 609 XRAPI_ATTR XrResult XRAPI_CALL 609 610 oxr_xrPassthroughStartFB(XrPassthroughFB passthrough); 610 611 #endif 612 + 613 + #ifdef OXR_HAVE_HTC_facial_tracking 614 + //! OpenXR API function @ep{xrCreateFacialTrackerHTC} 615 + XRAPI_ATTR XrResult XRAPI_CALL 616 + oxr_xrCreateFacialTrackerHTC(XrSession session, 617 + const XrFacialTrackerCreateInfoHTC *createInfo, 618 + XrFacialTrackerHTC *facialTracker); 619 + 620 + //! OpenXR API function @ep{xrDestroyFacialTrackerHTC} 621 + XRAPI_ATTR XrResult XRAPI_CALL 622 + oxr_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker); 623 + 624 + //! OpenXR API function @ep{xrGetFacialExpressionsHTC} 625 + XRAPI_ATTR XrResult XRAPI_CALL 626 + oxr_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions); 627 + #endif 628 + 611 629 /*! 612 630 * @} 613 631 */
+8 -1
src/xrt/state_trackers/oxr/oxr_api_negotiate.c
··· 1 - // Copyright 2018-2019, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief File for negotiating with the loader. 6 6 * @author Rylie Pavlik <rylie.pavlik@collabora.com> 7 7 * @author Jakob Bornecrantz <jakob@collabora.com> 8 + * @author Korcan Hussein <korcan.hussein@collabora.com> 8 9 * @ingroup oxr_api 9 10 */ 10 11 ··· 304 305 #ifdef OXR_HAVE_KHR_D3D12_enable 305 306 ENTRY_IF_EXT(xrGetD3D12GraphicsRequirementsKHR, KHR_D3D12_enable); 306 307 #endif // OXR_HAVE_KHR_D3D12_enable 308 + 309 + #ifdef OXR_HAVE_HTC_facial_tracking 310 + ENTRY_IF_EXT(xrCreateFacialTrackerHTC, HTC_facial_tracking); 311 + ENTRY_IF_EXT(xrDestroyFacialTrackerHTC, HTC_facial_tracking); 312 + ENTRY_IF_EXT(xrGetFacialExpressionsHTC, HTC_facial_tracking); 313 + #endif 307 314 308 315 /* 309 316 * Not logging here because there's no need to loudly advertise
+167 -1
src/xrt/state_trackers/oxr/oxr_api_session.c
··· 1 - // Copyright 2019-2020, Collabora, Ltd. 1 + // Copyright 2019-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief Session entrypoints for the OpenXR state tracker. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 + * @author Korcan Hussein <korcan.hussein@collabora.com> 7 8 * @ingroup oxr_api 8 9 */ 9 10 ··· 678 679 } 679 680 680 681 #endif 682 + 683 + #ifdef OXR_HAVE_HTC_facial_tracking 684 + 685 + static enum xrt_facial_tracking_type_htc 686 + oxr_to_xrt_facial_tracking_type_htc(enum XrFacialTrackingTypeHTC ft_type) 687 + { 688 + return (enum xrt_facial_tracking_type_htc)ft_type; 689 + } 690 + 691 + static enum xrt_input_name 692 + oxr_facial_tracking_type_htc_to_input_name(enum xrt_facial_tracking_type_htc ft_type) 693 + { 694 + switch (ft_type) { 695 + case XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC: return XRT_INPUT_HTC_LIP_FACE_TRACKING; 696 + case XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC: 697 + default: return XRT_INPUT_HTC_EYE_FACE_TRACKING; 698 + } 699 + } 700 + 701 + static XrResult 702 + oxr_facial_tracker_htc_destroy_cb(struct oxr_logger *log, struct oxr_handle_base *hb) 703 + { 704 + struct oxr_facial_tracker_htc *face_tracker_htc = (struct oxr_facial_tracker_htc *)hb; 705 + free(face_tracker_htc); 706 + return XR_SUCCESS; 707 + } 708 + 709 + XrResult 710 + oxr_facial_tracker_htc_create(struct oxr_logger *log, 711 + struct oxr_session *sess, 712 + const XrFacialTrackerCreateInfoHTC *createInfo, 713 + struct oxr_facial_tracker_htc **out_face_tracker_htc) 714 + { 715 + bool supports_eye = false; 716 + bool supports_lip = false; 717 + oxr_system_get_face_tracking_htc_support(log, sess->sys->inst, &supports_eye, &supports_lip); 718 + 719 + const enum xrt_facial_tracking_type_htc facial_tracking_type = 720 + oxr_to_xrt_facial_tracking_type_htc(createInfo->facialTrackingType); 721 + 722 + if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC && !supports_eye) { 723 + return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC eye facial tracking"); 724 + } 725 + if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC && !supports_lip) { 726 + return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC lip facial tracking"); 727 + } 728 + 729 + struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, face); 730 + if (xdev == NULL) { 731 + return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for face tracking role"); 732 + } 733 + 734 + if (!xdev->face_tracking_supported) { 735 + return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "Device does not support HTC facial tracking"); 736 + } 737 + 738 + struct oxr_facial_tracker_htc *face_tracker_htc = NULL; 739 + OXR_ALLOCATE_HANDLE_OR_RETURN(log, face_tracker_htc, OXR_XR_DEBUG_FTRACKER, oxr_facial_tracker_htc_destroy_cb, 740 + &sess->handle); 741 + 742 + face_tracker_htc->sess = sess; 743 + face_tracker_htc->xdev = xdev; 744 + face_tracker_htc->facial_tracking_type = facial_tracking_type; 745 + 746 + *out_face_tracker_htc = face_tracker_htc; 747 + 748 + return XR_SUCCESS; 749 + } 750 + 751 + XRAPI_ATTR XrResult XRAPI_CALL 752 + oxr_xrCreateFacialTrackerHTC(XrSession session, 753 + const XrFacialTrackerCreateInfoHTC *createInfo, 754 + XrFacialTrackerHTC *facialTracker) 755 + { 756 + OXR_TRACE_MARKER(); 757 + 758 + struct oxr_logger log; 759 + XrResult ret = XR_SUCCESS; 760 + struct oxr_session *sess = NULL; 761 + struct oxr_facial_tracker_htc *facial_tracker_htc = NULL; 762 + OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrCreateFacialTrackerHTC"); 763 + OXR_VERIFY_SESSION_NOT_LOST(&log, sess); 764 + OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, createInfo, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC); 765 + OXR_VERIFY_EXTENSION(&log, sess->sys->inst, HTC_facial_tracking); 766 + 767 + ret = oxr_facial_tracker_htc_create(&log, sess, createInfo, &facial_tracker_htc); 768 + if (ret != XR_SUCCESS) { 769 + return ret; 770 + } 771 + 772 + OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc); 773 + *facialTracker = oxr_facial_tracker_htc_to_openxr(facial_tracker_htc); 774 + 775 + return XR_SUCCESS; 776 + } 777 + 778 + XRAPI_ATTR XrResult XRAPI_CALL 779 + oxr_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker) 780 + { 781 + OXR_TRACE_MARKER(); 782 + 783 + struct oxr_logger log; 784 + struct oxr_facial_tracker_htc *facial_tracker_htc = NULL; 785 + OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialTracker, facial_tracker_htc, "xrDestroyFacialTrackerHTC"); 786 + 787 + return oxr_handle_destroy(&log, &facial_tracker_htc->handle); 788 + } 789 + 790 + XRAPI_ATTR XrResult XRAPI_CALL 791 + oxr_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions) 792 + { 793 + OXR_TRACE_MARKER(); 794 + 795 + struct oxr_logger log; 796 + struct oxr_facial_tracker_htc *facial_tracker_htc = NULL; 797 + OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialExpressions, facial_tracker_htc, 798 + "xrGetFacialExpressionsHTC"); 799 + OXR_VERIFY_SESSION_NOT_LOST(&log, facial_tracker_htc->sess); 800 + OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc->xdev); 801 + OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, facialExpressions, XR_TYPE_FACIAL_EXPRESSIONS_HTC); 802 + OXR_VERIFY_ARG_NOT_NULL(&log, facialExpressions->expressionWeightings); 803 + 804 + #define OXR_VERIFY_FACE_EXPRESSION_COUNT(fttype) \ 805 + if (facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_##fttype##_DEFAULT_HTC && \ 806 + facialExpressions->expressionCount < XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC) { \ 807 + return oxr_error( \ 808 + &log, XR_ERROR_SIZE_INSUFFICIENT, \ 809 + "\"expressionCount\" (%d) size is less than the minimum size (%d) required for " #fttype \ 810 + " expressions.\n", \ 811 + facialExpressions->expressionCount, XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC); \ 812 + } 813 + 814 + OXR_VERIFY_FACE_EXPRESSION_COUNT(EYE) 815 + OXR_VERIFY_FACE_EXPRESSION_COUNT(LIP) 816 + #undef OXR_VERIFY_FACE_EXPRESSION_COUNT 817 + 818 + const bool is_eye_tracking = 819 + facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC; 820 + const size_t expression_count = 821 + is_eye_tracking ? XRT_FACIAL_EXPRESSION_EYE_COUNT_HTC : XRT_FACIAL_EXPRESSION_LIP_COUNT_HTC; 822 + 823 + struct xrt_facial_expression_set facial_expression_set_result = {0}; 824 + float *expression_weights = is_eye_tracking 825 + ? facial_expression_set_result.eye_expression_set_htc.expression_weights 826 + : facial_expression_set_result.lip_expression_set_htc.expression_weights; 827 + memset(expression_weights, 0, sizeof(float) * expression_count); 828 + 829 + const enum xrt_input_name ft_input_name = 830 + oxr_facial_tracking_type_htc_to_input_name(facial_tracker_htc->facial_tracking_type); 831 + 832 + xrt_device_get_face_tracking(facial_tracker_htc->xdev, ft_input_name, &facial_expression_set_result); 833 + 834 + facialExpressions->isActive = facial_expression_set_result.base_expression_set_htc.is_active; 835 + if (facialExpressions->isActive == XR_FALSE) 836 + return XR_SUCCESS; 837 + 838 + const struct oxr_instance *inst = facial_tracker_htc->sess->sys->inst; 839 + facialExpressions->sampleTime = time_state_monotonic_to_ts_ns( 840 + inst->timekeeping, facial_expression_set_result.base_expression_set_htc.sample_time_ns); 841 + 842 + memcpy(facialExpressions->expressionWeightings, expression_weights, sizeof(float) * expression_count); 843 + 844 + return XR_SUCCESS; 845 + } 846 + #endif
+4 -1
src/xrt/state_trackers/oxr/oxr_api_verify.h
··· 1 - // Copyright 2018-2022, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief File for verifying app input into api functions. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 + * @author Korcan Hussein <korcan.hussein@collabora.com> 7 8 * @ingroup oxr_api 8 9 */ 9 10 ··· 71 72 OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_passthrough, PASSTHROUGH, name, new_thing->sess->sys->inst) 72 73 #define OXR_VERIFY_PASSTHROUGH_LAYER_AND_INIT_LOG(log, thing, new_thing, name) \ 73 74 OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_passthrough_layer, PASSTHROUGH_LAYER, name, new_thing->sess->sys->inst) 75 + #define OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(log, thing, new_thing, name) \ 76 + OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_facial_tracker_htc, FTRACKER, name, new_thing->sess->sys->inst) 74 77 // clang-format on 75 78 76 79 #define OXR_VERIFY_INSTANCE_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_instance, INSTANCE);
+14 -2
src/xrt/state_trackers/oxr/oxr_extension_support.h
··· 1 - // Copyright 2019-2023, Collabora, Ltd. 1 + // Copyright 2019-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 596 596 #define OXR_EXTENSION_SUPPORT_MNDX_system_buttons(_) 597 597 #endif 598 598 599 + 600 + /* 601 + * XR_HTC_facial_tracking 602 + */ 603 + #if defined(XR_HTC_facial_tracking) && defined(XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC) 604 + #define OXR_HAVE_HTC_facial_tracking 605 + #define OXR_EXTENSION_SUPPORT_HTC_facial_tracking(_) _(HTC_facial_tracking, HTC_FACIAL_TRACKING) 606 + #else 607 + #define OXR_EXTENSION_SUPPORT_HTC_facial_tracking(_) 608 + #endif 609 + 599 610 // end of GENERATED per-extension defines - do not modify - used by scripts 600 611 601 612 /*! ··· 670 681 OXR_EXTENSION_SUPPORT_MNDX_egl_enable(_) \ 671 682 OXR_EXTENSION_SUPPORT_MNDX_force_feedback_curl(_) \ 672 683 OXR_EXTENSION_SUPPORT_MNDX_hydra(_) \ 673 - OXR_EXTENSION_SUPPORT_MNDX_system_buttons(_) 684 + OXR_EXTENSION_SUPPORT_MNDX_system_buttons(_) \ 685 + OXR_EXTENSION_SUPPORT_HTC_facial_tracking(_) 674 686 // clang-format on
+4 -1
src/xrt/state_trackers/oxr/oxr_instance.c
··· 1 - // Copyright 2018-2023, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 283 283 #endif 284 284 #ifdef OXR_HAVE_EXT_hand_interaction 285 285 .ext_hand_interaction_enabled = extensions->EXT_hand_interaction, 286 + #endif 287 + #ifdef OXR_HAVE_HTC_facial_tracking 288 + .htc_facial_tracking_enabled = extensions->HTC_facial_tracking, 286 289 #endif 287 290 }; 288 291 snprintf(i_info.application_name, sizeof(inst->xinst->instance_info.application_name), "%s",
+43
src/xrt/state_trackers/oxr/oxr_objects.h
··· 121 121 struct oxr_action_set_ref; 122 122 struct oxr_action_ref; 123 123 struct oxr_hand_tracker; 124 + struct oxr_facial_tracker_htc; 124 125 125 126 #define XRT_MAX_HANDLE_CHILDREN 256 126 127 #define OXR_MAX_BINDINGS_PER_ACTION 32 ··· 382 383 return XRT_CAST_PTR_TO_OXR_HANDLE(XrAction, act); 383 384 } 384 385 386 + #ifdef OXR_HAVE_HTC_facial_tracking 387 + /*! 388 + * To go back to a OpenXR object. 389 + * 390 + * @relates oxr_facial_tracker_htc 391 + */ 392 + static inline XrFacialTrackerHTC 393 + oxr_facial_tracker_htc_to_openxr(struct oxr_facial_tracker_htc *face_tracker_htc) 394 + { 395 + return XRT_CAST_PTR_TO_OXR_HANDLE(XrFacialTrackerHTC, face_tracker_htc); 396 + } 397 + #endif 385 398 386 399 /*! 387 400 * ··· 951 964 952 965 bool 953 966 oxr_system_get_force_feedback_support(struct oxr_logger *log, struct oxr_instance *inst); 967 + 968 + void 969 + oxr_system_get_face_tracking_htc_support(struct oxr_logger *log, 970 + struct oxr_instance *inst, 971 + bool *supports_eye, 972 + bool *supports_lip); 954 973 955 974 956 975 /* ··· 2546 2565 XrPassthroughStateChangedFlagsFB flags); 2547 2566 2548 2567 #endif // OXR_HAVE_FB_passthrough 2568 + 2569 + /*! 2570 + * HTC specific Facial tracker. 2571 + * 2572 + * Parent type/handle is @ref oxr_instance 2573 + * 2574 + * 2575 + * @obj{XrFacialTrackerHTC} 2576 + * @extends oxr_handle_base 2577 + */ 2578 + struct oxr_facial_tracker_htc 2579 + { 2580 + //! Common structure for things referred to by OpenXR handles. 2581 + struct oxr_handle_base handle; 2582 + 2583 + //! Owner of this face tracker. 2584 + struct oxr_session *sess; 2585 + 2586 + //! xrt_device backing this face tracker 2587 + struct xrt_device *xdev; 2588 + 2589 + //! Type of facial tracking, eyes or lips 2590 + enum xrt_facial_tracking_type_htc facial_tracking_type; 2591 + }; 2549 2592 2550 2593 /*! 2551 2594 * @}
+4 -1
src/xrt/state_trackers/oxr/oxr_session.c
··· 1 - // Copyright 2018-2023, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 228 228 #endif 229 229 #ifdef OXR_HAVE_EXT_hand_interaction 230 230 .ext_hand_interaction_enabled = extensions->EXT_hand_interaction, 231 + #endif 232 + #ifdef OXR_HAVE_HTC_facial_tracking 233 + .htc_facial_tracking_enabled = extensions->HTC_facial_tracking, 231 234 #endif 232 235 }; 233 236
+46 -1
src/xrt/state_trackers/oxr/oxr_system.c
··· 1 - // Copyright 2018-2020, Collabora, Ltd. 1 + // Copyright 2018-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 * @brief Holds system related entrypoints. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 + * @author Korcan Hussein <korcan.hussein@collabora.com> 7 8 * @ingroup oxr_main 8 9 */ 9 10 ··· 269 270 return left_supported || right_supported; 270 271 } 271 272 273 + void 274 + oxr_system_get_face_tracking_htc_support(struct oxr_logger *log, 275 + struct oxr_instance *inst, 276 + bool *supports_eye, 277 + bool *supports_lip) 278 + { 279 + struct oxr_system *sys = &inst->system; 280 + struct xrt_device *face_xdev = GET_XDEV_BY_ROLE(sys, face); 281 + 282 + if (supports_eye) 283 + *supports_eye = false; 284 + if (supports_lip) 285 + *supports_lip = false; 286 + 287 + if (face_xdev == NULL || !face_xdev->face_tracking_supported || face_xdev->inputs == NULL) { 288 + return; 289 + } 290 + 291 + for (size_t input_idx = 0; input_idx < face_xdev->input_count; ++input_idx) { 292 + const struct xrt_input *input = &face_xdev->inputs[input_idx]; 293 + if (supports_eye != NULL && input->name == XRT_INPUT_HTC_EYE_FACE_TRACKING) { 294 + *supports_eye = true; 295 + } 296 + if (supports_lip != NULL && input->name == XRT_INPUT_HTC_LIP_FACE_TRACKING) { 297 + *supports_eye = true; 298 + } 299 + } 300 + } 301 + 272 302 XrResult 273 303 oxr_system_get_properties(struct oxr_logger *log, struct oxr_system *sys, XrSystemProperties *properties) 274 304 { ··· 347 377 } 348 378 #endif 349 379 380 + #ifdef OXR_HAVE_HTC_facial_tracking 381 + XrSystemFacialTrackingPropertiesHTC *htc_facial_tracking_props = NULL; 382 + if (sys->inst->extensions.HTC_facial_tracking) { 383 + htc_facial_tracking_props = OXR_GET_OUTPUT_FROM_CHAIN( 384 + properties, XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC, XrSystemFacialTrackingPropertiesHTC); 385 + } 386 + 387 + if (htc_facial_tracking_props) { 388 + bool supports_eye = false; 389 + bool supports_lip = false; 390 + oxr_system_get_face_tracking_htc_support(log, sys->inst, &supports_eye, &supports_lip); 391 + htc_facial_tracking_props->supportEyeFacialTracking = supports_eye; 392 + htc_facial_tracking_props->supportLipFacialTracking = supports_lip; 393 + } 394 + #endif // OXR_HAVE_HTC_facial_tracking 350 395 return XR_SUCCESS; 351 396 } 352 397