+2

CMakeLists.txt

··· 372 372 option(XRT_FEATURE_OPENXR_VULKAN_SWAPCHAIN_FORMAT_LIST "Enable XR_KHR_vulkan_swapchain_format_list" ON) 373 373 option(XRT_FEATURE_OPENXR_XDEV_SPACE "Enable XR_MNDX_xdev_space" ON) 374 374 option_with_deps(XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META "Enable XR_META_body_tracking_full_body" DEPENDS XRT_FEATURE_OPENXR_BODY_TRACKING_FB) 375 375 + option_with_deps(XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META "Enable XR_META_body_tracking_calibration" DEPENDS XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META) 375 376 376 377 # Interaction extension support. 377 378 option(XRT_FEATURE_OPENXR_INTERACTION_EXT_EYE_GAZE "Enable XR_EXT_eye_gaze_interaction" ON) ··· 599 600 message(STATUS "# FEATURE_OPENXR: ${XRT_FEATURE_OPENXR}") 600 601 message(STATUS "# FEATURE_OPENXR_ACTIVE_ACTION_SET_PRIORITY: ${XRT_FEATURE_OPENXR_ACTIVE_ACTION_SET_PRIORITY}") 601 602 message(STATUS "# FEATURE_OPENXR_BODY_TRACKING_FB: ${XRT_FEATURE_OPENXR_BODY_TRACKING_FB}") 603 603 + message(STATUS "# FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META: ${XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META}") 602 604 message(STATUS "# FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META: ${XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META}") 603 605 message(STATUS "# FEATURE_OPENXR_FACE_TRACKING2_FB: ${XRT_FEATURE_OPENXR_FACE_TRACKING2_FB}") 604 606 message(STATUS "# FEATURE_OPENXR_DEBUG_UTILS: ${XRT_FEATURE_OPENXR_DEBUG_UTILS}")

+1

scripts/generate_oxr_ext_support.py

··· 90 90 ['XR_HTC_facial_tracking', 'XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC'], 91 91 ['XR_HTC_vive_cosmos_controller_interaction', 'XRT_FEATURE_OPENXR_INTERACTION_VIVE_COSMOS'], 92 92 ['XR_HTC_vive_focus3_controller_interaction', 'XRT_FEATURE_OPENXR_INTERACTION_VIVE_FOCUS3'], 93 93 + ['XR_META_body_tracking_calibration', 'XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META'], 93 94 ['XR_META_body_tracking_full_body', 'XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META'], 94 95 ['XR_META_touch_controller_plus', 'XRT_FEATURE_OPENXR_INTERACTION_TOUCH_PLUS'], 95 96 ['XR_ML_ml2_controller_interaction', 'XRT_FEATURE_OPENXR_INTERACTION_ML2'],

+1

scripts/mapping.imp

··· 35 35 { symbol: ["XRT_FEATURE_IPC_CLIENT", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 36 36 { symbol: ["XRT_FEATURE_OPENXR", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 37 37 { symbol: ["XRT_FEATURE_OPENXR_ACTIVE_ACTION_SET_PRIORITY", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 38 38 + { symbol: ["XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 38 39 { symbol: ["XRT_FEATURE_OPENXR_BODY_TRACKING_FB", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 39 40 { symbol: ["XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META", "public", "\"xrt/xrt_config_build.h\"", "public"] }, 40 41 { symbol: ["XRT_FEATURE_OPENXR_DEBUG_UTILS", "public", "\"xrt/xrt_config_build.h\"", "public"] },

+1

src/xrt/compositor/multi/comp_multi_system.c

··· 421 421 .fb_body_tracking_enabled = false, 422 422 .fb_face_tracking2_enabled = false, 423 423 .meta_body_tracking_full_body_enabled = false, 424 424 + .meta_body_tracking_calibration_enabled = false, 424 425 }; 425 426 426 427 switch (msc->sessions.state) {

+1

src/xrt/include/xrt/xrt_compositor.h

··· 972 972 bool fb_body_tracking_enabled; 973 973 bool fb_face_tracking2_enabled; 974 974 bool meta_body_tracking_full_body_enabled; 975 975 + bool meta_body_tracking_calibration_enabled; 975 976 }; 976 977 977 978 /*!

+1

src/xrt/include/xrt/xrt_config_build.h.cmake_in

··· 32 32 #cmakedefine XRT_FEATURE_IPC_CLIENT 33 33 #cmakedefine XRT_FEATURE_OPENXR 34 34 #cmakedefine XRT_FEATURE_OPENXR_ACTIVE_ACTION_SET_PRIORITY 35 35 + #cmakedefine XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META 35 36 #cmakedefine XRT_FEATURE_OPENXR_BODY_TRACKING_FB 36 37 #cmakedefine XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META 37 38 #cmakedefine XRT_FEATURE_OPENXR_DEBUG_UTILS

+17

src/xrt/include/xrt/xrt_defines.h

··· 1847 1847 XRT_BODY_JOINT_SET_FULL_BODY_META, 1848 1848 }; 1849 1849 1850 1850 + // XR_META_body_tracking_calibration 1851 1851 + enum xrt_body_tracking_calibration_state_meta 1852 1852 + { 1853 1853 + // Valid calibration, pose is safe to use 1854 1854 + XRT_BODY_TRACKING_CALIBRATION_STATE_VALID_META = 1, 1855 1855 + // Calibration is still running, pose may be incorrect 1856 1856 + XRT_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META = 2, 1857 1857 + // Calibration is invalid, pose is not safe to use 1858 1858 + XRT_BODY_TRACKING_CALIBRATION_STATE_INVALID_META = 3, 1859 1859 + }; 1860 1860 + 1850 1861 // XR_FB_body_tracking 1851 1862 struct xrt_body_skeleton_joint_fb 1852 1863 { ··· 1890 1901 float confidence; 1891 1902 uint32_t skeleton_changed_count; 1892 1903 XRT_ALIGNAS(8) bool is_active; 1904 1904 + 1905 1905 + struct 1906 1906 + { 1907 1907 + // Requires XR_META_body_tracking_calibration, @ref xrt_device_supported::body_tracking_calibration 1908 1908 + enum xrt_body_tracking_calibration_state_meta calibration_status; 1909 1909 + } exts; 1893 1910 }; 1894 1911 1895 1912 // XR_FB_body_tracking

+49

src/xrt/include/xrt/xrt_device.h

··· 263 263 bool stage; 264 264 bool face_tracking; 265 265 bool body_tracking; 266 266 + bool body_tracking_calibration; 266 267 bool battery_status; 267 268 bool brightness_control; 268 269 ··· 432 433 enum xrt_input_name body_tracking_type, 433 434 int64_t desired_timestamp_ns, 434 435 struct xrt_body_joint_set *out_value); 436 436 + 437 437 + /*! 438 438 + * @brief XR_META_body_tracking_calibration - body tracking extension to reset the body tracking calibration 439 439 + * 440 440 + * @param[in] xdev The body tracking device. 441 441 + */ 442 442 + xrt_result_t (*reset_body_tracking_calibration_meta)(struct xrt_device *xdev); 443 443 + 444 444 + /*! 445 445 + * @brief XR_META_body_tracking_calibration - body tracking extension to suggest a body tracking calibration 446 446 + * override 447 447 + * 448 448 + * @param[in] xdev The body tracking device. 449 449 + * @param[in] new_body_height The suggested new body height to override. 450 450 + */ 451 451 + xrt_result_t (*set_body_tracking_calibration_override_meta)(struct xrt_device *xdev, float new_body_height); 435 452 436 453 /*! 437 454 * Set a output value. ··· 763 780 struct xrt_body_joint_set *out_value) 764 781 { 765 782 return xdev->get_body_joints(xdev, body_tracking_type, desired_timestamp_ns, out_value); 783 783 + } 784 784 + 785 785 + /*! 786 786 + * Helper function for @ref xrt_device::reset_body_tracking_calibration_meta. 787 787 + * 788 788 + * @copydoc xrt_device::reset_body_tracking_calibration_meta 789 789 + * 790 790 + * @public @memberof xrt_device 791 791 + */ 792 792 + static inline xrt_result_t 793 793 + xrt_device_reset_body_tracking_calibration_meta(struct xrt_device *xdev) 794 794 + { 795 795 + if (xdev->reset_body_tracking_calibration_meta == NULL) { 796 796 + return XRT_ERROR_NOT_IMPLEMENTED; 797 797 + } 798 798 + return xdev->reset_body_tracking_calibration_meta(xdev); 799 799 + } 800 800 + 801 801 + /*! 802 802 + * Helper function for @ref xrt_device::set_body_tracking_calibration_override_meta. 803 803 + * 804 804 + * @copydoc xrt_device::set_body_tracking_calibration_override_meta 805 805 + * 806 806 + * @public @memberof xrt_device 807 807 + */ 808 808 + static inline xrt_result_t 809 809 + xrt_device_set_body_tracking_calibration_override_meta(struct xrt_device *xdev, float new_body_height) 810 810 + { 811 811 + if (xdev->set_body_tracking_calibration_override_meta == NULL) { 812 812 + return XRT_ERROR_NOT_IMPLEMENTED; 813 813 + } 814 814 + return xdev->set_body_tracking_calibration_override_meta(xdev, new_body_height); 766 815 } 767 816 768 817 /*!

+1

src/xrt/include/xrt/xrt_instance.h

··· 79 79 bool fb_body_tracking_enabled; 80 80 bool fb_face_tracking2_enabled; 81 81 bool meta_body_tracking_full_body_enabled; 82 82 + bool meta_body_tracking_calibration_enabled; 82 83 }; 83 84 84 85 /*!

+26

src/xrt/ipc/client/ipc_client_xdev.c

··· 128 128 } 129 129 130 130 static xrt_result_t 131 131 + ipc_client_xdev_reset_body_tracking_calibration_meta(struct xrt_device *xdev) 132 132 + { 133 133 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 134 134 + 135 135 + xrt_result_t xret = ipc_call_device_reset_body_tracking_calibration_meta( // 136 136 + icx->ipc_c, // 137 137 + icx->device_id); // 138 138 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_reset_body_tracking_calibration_meta"); 139 139 + } 140 140 + 141 141 + static xrt_result_t 142 142 + ipc_client_xdev_set_body_tracking_calibration_override_meta(struct xrt_device *xdev, float new_body_height) 143 143 + { 144 144 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 145 145 + 146 146 + xrt_result_t xret = ipc_call_device_set_body_tracking_calibration_override_meta( // 147 147 + icx->ipc_c, // 148 148 + icx->device_id, // 149 149 + new_body_height); // 150 150 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_set_body_tracking_calibration_override_meta"); 151 151 + } 152 152 + 153 153 + static xrt_result_t 131 154 ipc_client_xdev_get_presence(struct xrt_device *xdev, bool *presence) 132 155 { 133 156 struct ipc_client_xdev *icx = ipc_client_xdev(xdev); ··· 385 408 icx->base.get_face_tracking = ipc_client_xdev_get_face_tracking; 386 409 icx->base.get_body_skeleton = ipc_client_xdev_get_body_skeleton; 387 410 icx->base.get_body_joints = ipc_client_xdev_get_body_joints; 411 411 + icx->base.reset_body_tracking_calibration_meta = ipc_client_xdev_reset_body_tracking_calibration_meta; 412 412 + icx->base.set_body_tracking_calibration_override_meta = 413 413 + ipc_client_xdev_set_body_tracking_calibration_override_meta; 388 414 icx->base.get_presence = ipc_client_xdev_get_presence; 389 415 icx->base.set_output = ipc_client_xdev_set_output; 390 416 icx->base.get_output_limits = ipc_client_xdev_get_output_limits;

+18

src/xrt/ipc/server/ipc_server_handler.c

··· 335 335 EXT(htc_facial_tracking_enabled); 336 336 EXT(fb_body_tracking_enabled); 337 337 EXT(meta_body_tracking_full_body_enabled); 338 338 + EXT(meta_body_tracking_calibration_enabled); 338 339 EXT(fb_face_tracking2_enabled); 339 340 340 341 #undef EXT ··· 432 433 .fb_body_tracking_enabled = ics->client_state.info.fb_body_tracking_enabled, 433 434 .fb_face_tracking2_enabled = ics->client_state.info.fb_face_tracking2_enabled, 434 435 .meta_body_tracking_full_body_enabled = ics->client_state.info.meta_body_tracking_full_body_enabled, 436 436 + .meta_body_tracking_calibration_enabled = ics->client_state.info.meta_body_tracking_calibration_enabled, 435 437 }; 436 438 437 439 return xrt_comp_begin_session(ics->xc, &begin_session_info); ··· 2526 2528 struct xrt_device *xdev = NULL; 2527 2529 GET_XDEV_OR_RETURN(ics, id, xdev); 2528 2530 return xrt_device_get_body_joints(xdev, body_tracking_type, desired_timestamp_ns, out_value); 2531 2531 + } 2532 2532 + 2533 2533 + xrt_result_t 2534 2534 + ipc_handle_device_reset_body_tracking_calibration_meta(volatile struct ipc_client_state *ics, uint32_t id) 2535 2535 + { 2536 2536 + struct xrt_device *xdev = get_xdev(ics, id); 2537 2537 + return xrt_device_reset_body_tracking_calibration_meta(xdev); 2538 2538 + } 2539 2539 + 2540 2540 + xrt_result_t 2541 2541 + ipc_handle_device_set_body_tracking_calibration_override_meta(volatile struct ipc_client_state *ics, 2542 2542 + uint32_t id, 2543 2543 + float new_body_height) 2544 2544 + { 2545 2545 + struct xrt_device *xdev = get_xdev(ics, id); 2546 2546 + return xrt_device_set_body_tracking_calibration_override_meta(xdev, new_body_height); 2529 2547 } 2530 2548 2531 2549 xrt_result_t

+2 -2

src/xrt/ipc/shared/ipc_protocol.h

··· 312 312 struct xrt_application_info info; 313 313 }; 314 314 315 315 - static_assert(sizeof(struct ipc_client_description) == 140, 315 315 + static_assert(sizeof(struct ipc_client_description) == 144, 316 316 "invalid structure size, maybe different 32/64 bits sizes or padding"); 317 317 318 318 struct ipc_client_list ··· 345 345 struct xrt_application_info info; 346 346 }; 347 347 348 348 - static_assert(sizeof(struct ipc_app_state) == 156, 348 348 + static_assert(sizeof(struct ipc_app_state) == 160, 349 349 "invalid structure size, maybe different 32/64 bits sizes or padding"); 350 350 351 351

+13

src/xrt/ipc/shared/proto.json

··· 596 596 ] 597 597 }, 598 598 599 599 + "device_reset_body_tracking_calibration_meta": { 600 600 + "in": [ 601 601 + {"name": "id", "type": "uint32_t"} 602 602 + ] 603 603 + }, 604 604 + 605 605 + "device_set_body_tracking_calibration_override_meta": { 606 606 + "in": [ 607 607 + {"name": "id", "type": "uint32_t"}, 608 608 + {"name": "new_body_height", "type": "float"} 609 609 + ] 610 610 + }, 611 611 + 599 612 "device_get_battery_status": { 600 613 "in": [ 601 614 {"name": "id", "type": "uint32_t"}

+63 -1

src/xrt/state_trackers/oxr/oxr_api_body_tracking.c

··· 19 19 #include "oxr_api_funcs.h" 20 20 #include "oxr_api_verify.h" 21 21 #include "oxr_handle.h" 22 22 + #include "oxr_chain.h" 22 23 23 24 XRAPI_ATTR XrResult XRAPI_CALL 24 25 oxr_xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker) ··· 91 92 OXR_VERIFY_ARG_NOT_NULL(&log, body_tracker_fb->xdev); 92 93 OXR_VERIFY_ARG_NOT_NULL(&log, locations->jointLocations); 93 94 OXR_VERIFY_SPACE_NOT_NULL(&log, locateInfo->baseSpace, base_spc); 95 95 + #ifdef OXR_HAVE_META_body_tracking_calibration 96 96 + XrBodyTrackingCalibrationStatusMETA *calibration_status = OXR_GET_OUTPUT_FROM_CHAIN( 97 97 + locations, XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META, XrBodyTrackingCalibrationStatusMETA); 98 98 + if (calibration_status != NULL) { 99 99 + OXR_VERIFY_EXTENSION(&log, body_tracker_fb->sess->sys->inst, META_body_tracking_calibration); 100 100 + } 101 101 + #endif 102 102 + return oxr_locate_body_joints_fb(&log, body_tracker_fb, base_spc, locateInfo, locations); 103 103 + } 94 104 95 95 - return oxr_locate_body_joints_fb(&log, body_tracker_fb, base_spc, locateInfo, locations); 105 105 + #ifdef OXR_HAVE_META_body_tracking_calibration 106 106 + XRAPI_ATTR XrResult XRAPI_CALL 107 107 + oxr_xrResetBodyTrackingCalibrationMETA(XrBodyTrackerFB bodyTracker) 108 108 + { 109 109 + OXR_TRACE_MARKER(); 110 110 + 111 111 + struct oxr_logger log; 112 112 + struct oxr_body_tracker_fb *body_tracker_fb = NULL; 113 113 + OXR_VERIFY_BODY_TRACKER_FB_AND_INIT_LOG(&log, bodyTracker, body_tracker_fb, 114 114 + "xrResetBodyTrackingCalibrationMETA"); 115 115 + OXR_VERIFY_SESSION_NOT_LOST(&log, body_tracker_fb->sess); 116 116 + OXR_VERIFY_ARG_NOT_NULL(&log, body_tracker_fb->xdev); 117 117 + OXR_VERIFY_EXTENSION(&log, body_tracker_fb->sess->sys->inst, META_body_tracking_calibration); 118 118 + 119 119 + if (!body_tracker_fb->xdev->supported.body_tracking_calibration) { 120 120 + return oxr_error(&log, XR_ERROR_FEATURE_UNSUPPORTED, 121 121 + "Body tracking device does not support this operation"); 122 122 + } 123 123 + 124 124 + const xrt_result_t result = xrt_device_reset_body_tracking_calibration_meta(body_tracker_fb->xdev); 125 125 + if (result != XRT_SUCCESS) { 126 126 + return oxr_error(&log, XR_ERROR_RUNTIME_FAILURE, "resetting body tracking calibration failed"); 127 127 + } 128 128 + return XR_SUCCESS; 129 129 + } 130 130 + 131 131 + XRAPI_ATTR XrResult XRAPI_CALL 132 132 + oxr_xrSuggestBodyTrackingCalibrationOverrideMETA(XrBodyTrackerFB bodyTracker, 133 133 + const XrBodyTrackingCalibrationInfoMETA *calibrationInfo) 134 134 + { 135 135 + OXR_TRACE_MARKER(); 136 136 + 137 137 + struct oxr_logger log; 138 138 + struct oxr_body_tracker_fb *body_tracker_fb = NULL; 139 139 + OXR_VERIFY_BODY_TRACKER_FB_AND_INIT_LOG(&log, bodyTracker, body_tracker_fb, 140 140 + "xrSuggestBodyTrackingCalibrationOverrideMETA"); 141 141 + OXR_VERIFY_SESSION_NOT_LOST(&log, body_tracker_fb->sess); 142 142 + OXR_VERIFY_ARG_NOT_NULL(&log, body_tracker_fb->xdev); 143 143 + OXR_VERIFY_EXTENSION(&log, body_tracker_fb->sess->sys->inst, META_body_tracking_calibration); 144 144 + OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, calibrationInfo, XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META); 145 145 + 146 146 + if (!body_tracker_fb->xdev->supported.body_tracking_calibration) { 147 147 + return oxr_error(&log, XR_ERROR_FEATURE_UNSUPPORTED, 148 148 + "Body tracking device does not support this operation"); 149 149 + } 150 150 + 151 151 + const xrt_result_t result = 152 152 + xrt_device_set_body_tracking_calibration_override_meta(body_tracker_fb->xdev, calibrationInfo->bodyHeight); 153 153 + if (result != XRT_SUCCESS) { 154 154 + return oxr_error(&log, XR_ERROR_RUNTIME_FAILURE, "overriding body tracking calibration failed"); 155 155 + } 156 156 + return XR_SUCCESS; 96 157 } 158 158 + #endif

+17

src/xrt/state_trackers/oxr/oxr_api_funcs.h

··· 748 748 oxr_xrCreateXDevSpaceMNDX(XrSession session, const XrCreateXDevSpaceInfoMNDX *createInfo, XrSpace *space); 749 749 #endif 750 750 751 751 + /* 752 752 + * 753 753 + * oxr_api_body_tracking.c 754 754 + * 755 755 + */ 756 756 + 757 757 + #ifdef OXR_HAVE_META_body_tracking_calibration 758 758 + //! OpenXR API function @ep{xrResetBodyTrackingCalibrationMETA} 759 759 + XRAPI_ATTR XrResult XRAPI_CALL 760 760 + oxr_xrResetBodyTrackingCalibrationMETA(XrBodyTrackerFB bodyTracker); 761 761 + 762 762 + //! OpenXR API function @ep{xrSuggestBodyTrackingCalibrationOverrideMETA} 763 763 + XRAPI_ATTR XrResult XRAPI_CALL 764 764 + oxr_xrSuggestBodyTrackingCalibrationOverrideMETA(XrBodyTrackerFB bodyTracker, 765 765 + const XrBodyTrackingCalibrationInfoMETA *calibrationInfo); 766 766 + #endif 767 767 + 751 768 /*! 752 769 * @} 753 770 */

+5

src/xrt/state_trackers/oxr/oxr_api_negotiate.c

··· 409 409 ENTRY_IF_EXT(xrCreateXDevSpaceMNDX, MNDX_xdev_space); 410 410 #endif // OXR_HAVE_MNDX_xdev_space 411 411 412 412 + #ifdef OXR_HAVE_META_body_tracking_calibration 413 413 + ENTRY_IF_EXT(xrResetBodyTrackingCalibrationMETA, META_body_tracking_calibration); 414 414 + ENTRY_IF_EXT(xrSuggestBodyTrackingCalibrationOverrideMETA, META_body_tracking_calibration); 415 415 + #endif 416 416 + 412 417 #ifdef OXR_HAVE_KHR_extended_struct_name_lengths 413 418 ENTRY_IF_EXT(xrStructureTypeToString2KHR, KHR_extended_struct_name_lengths); 414 419 #endif // OXR_HAVE_KHR_extended_struct_name_lengths

+15

src/xrt/state_trackers/oxr/oxr_body_tracking.c

··· 19 19 #include "oxr_logger.h" 20 20 #include "oxr_handle.h" 21 21 #include "oxr_conversions.h" 22 22 + #include "oxr_chain.h" 22 23 23 24 static enum xrt_body_joint_set_type_fb 24 25 oxr_to_xrt_body_joint_set_type_fb(XrBodyJointSetFB joint_set_type) ··· 206 207 m_relation_chain_resolve(&chain, &result); 207 208 OXR_XRT_POSE_TO_XRPOSEF(result.pose, dst_joint->pose); 208 209 } 210 210 + 211 211 + #ifdef OXR_HAVE_META_body_tracking_calibration 212 212 + XrBodyTrackingCalibrationStatusMETA *calibration_status = OXR_GET_OUTPUT_FROM_CHAIN( 213 213 + locations, XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META, XrBodyTrackingCalibrationStatusMETA); 214 214 + if (calibration_status != NULL) { 215 215 + if (!body_tracker_fb->xdev->supported.body_tracking_calibration) { 216 216 + return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, 217 217 + "body tracking device does not support XR_META_body_tracking_calibration"); 218 218 + } 219 219 + calibration_status->status = 220 220 + (XrBodyTrackingCalibrationStateMETA)body_joint_set_fb->exts.calibration_status; 221 221 + } 222 222 + #endif 223 223 + 209 224 return XR_SUCCESS; 210 225 }

+13

src/xrt/state_trackers/oxr/oxr_extension_support.h

··· 636 636 637 637 638 638 /* 639 639 + * XR_META_body_tracking_calibration 640 640 + */ 641 641 + #if defined(XR_META_body_tracking_calibration) && defined(XRT_FEATURE_OPENXR_BODY_TRACKING_CALIBRATION_META) 642 642 + #define OXR_HAVE_META_body_tracking_calibration 643 643 + #define OXR_EXTENSION_SUPPORT_META_body_tracking_calibration(_) \ 644 644 + _(META_body_tracking_calibration, META_BODY_TRACKING_CALIBRATION) 645 645 + #else 646 646 + #define OXR_EXTENSION_SUPPORT_META_body_tracking_calibration(_) 647 647 + #endif 648 648 + 649 649 + 650 650 + /* 639 651 * XR_META_body_tracking_full_body 640 652 */ 641 653 #if defined(XR_META_body_tracking_full_body) && defined(XRT_FEATURE_OPENXR_BODY_TRACKING_FULL_BODY_META) ··· 905 917 OXR_EXTENSION_SUPPORT_HTC_facial_tracking(_) \ 906 918 OXR_EXTENSION_SUPPORT_HTC_vive_cosmos_controller_interaction(_) \ 907 919 OXR_EXTENSION_SUPPORT_HTC_vive_focus3_controller_interaction(_) \ 920 920 + OXR_EXTENSION_SUPPORT_META_body_tracking_calibration(_) \ 908 921 OXR_EXTENSION_SUPPORT_META_body_tracking_full_body(_) \ 909 922 OXR_EXTENSION_SUPPORT_META_touch_controller_plus(_) \ 910 923 OXR_EXTENSION_SUPPORT_ML_ml2_controller_interaction(_) \

+3

src/xrt/state_trackers/oxr/oxr_instance.c

··· 325 325 #ifdef OXR_HAVE_META_body_tracking_full_body 326 326 .meta_body_tracking_full_body_enabled = extensions->META_body_tracking_full_body, 327 327 #endif 328 328 + #ifdef OXR_HAVE_META_body_tracking_calibration 329 329 + .meta_body_tracking_calibration_enabled = extensions->META_body_tracking_calibration, 330 330 + #endif 328 331 }; 329 332 snprintf(i_info.app_info.application_name, sizeof(i_info.app_info.application_name), "%s", 330 333 createInfo->applicationInfo.applicationName);

+3

src/xrt/state_trackers/oxr/oxr_objects.h

··· 1104 1104 bool 1105 1105 oxr_system_get_full_body_tracking_meta_support(struct oxr_logger *log, struct oxr_instance *inst); 1106 1106 1107 1107 + bool 1108 1108 + oxr_system_get_body_tracking_calibration_meta_support(struct oxr_logger *log, struct oxr_instance *inst); 1109 1109 + 1107 1110 /* 1108 1111 * 1109 1112 * oxr_event.cpp

+3

src/xrt/state_trackers/oxr/oxr_session.c

··· 264 264 #ifdef OXR_HAVE_META_body_tracking_full_body 265 265 .meta_body_tracking_full_body_enabled = extensions->META_body_tracking_full_body, 266 266 #endif 267 267 + #ifdef OXR_HAVE_META_body_tracking_calibration 268 268 + .meta_body_tracking_calibration_enabled = extensions->META_body_tracking_calibration, 269 269 + #endif 267 270 }; 268 271 269 272 xrt_result_t xret = xrt_comp_begin_session(xc, &begin_session_info);

+26

src/xrt/state_trackers/oxr/oxr_system.c

··· 383 383 return oxr_system_get_body_tracking_support(log, inst, XRT_INPUT_META_FULL_BODY_TRACKING); 384 384 } 385 385 386 386 + bool 387 387 + oxr_system_get_body_tracking_calibration_meta_support(struct oxr_logger *log, struct oxr_instance *inst) 388 388 + { 389 389 + if (!oxr_system_get_body_tracking_fb_support(log, inst) && 390 390 + !oxr_system_get_full_body_tracking_meta_support(log, inst)) { 391 391 + return false; 392 392 + } 393 393 + struct oxr_system *sys = &inst->system; 394 394 + const struct xrt_device *body = GET_XDEV_BY_ROLE(sys, body); 395 395 + return body->supported.body_tracking_calibration; 396 396 + } 397 397 + 386 398 XrResult 387 399 oxr_system_get_properties(struct oxr_logger *log, struct oxr_system *sys, XrSystemProperties *properties) 388 400 { ··· 558 570 oxr_system_get_full_body_tracking_meta_support(log, sys->inst); 559 571 } 560 572 #endif // OXR_HAVE_META_body_tracking_full_body 573 573 + 574 574 + #ifdef OXR_HAVE_META_body_tracking_calibration 575 575 + XrSystemPropertiesBodyTrackingCalibrationMETA *body_tracking_calibration_meta_props = NULL; 576 576 + if (sys->inst->extensions.META_body_tracking_calibration) { 577 577 + body_tracking_calibration_meta_props = 578 578 + OXR_GET_OUTPUT_FROM_CHAIN(properties, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META, 579 579 + XrSystemPropertiesBodyTrackingCalibrationMETA); 580 580 + } 581 581 + 582 582 + if (body_tracking_calibration_meta_props) { 583 583 + body_tracking_calibration_meta_props->supportsHeightOverride = 584 584 + oxr_system_get_body_tracking_calibration_meta_support(log, sys->inst); 585 585 + } 586 586 + #endif // OXR_HAVE_META_body_tracking_calibration 561 587 562 588 return XR_SUCCESS; 563 589 }