+6 -2

src/xrt/auxiliary/util/u_builders.c

··· 243 */ 244 245 xsysd->static_roles.head = ubrh.head; 246 - xsysd->static_roles.hand_tracking.left = ubrh.hand_tracking.left; 247 - xsysd->static_roles.hand_tracking.right = ubrh.hand_tracking.right; 0 0 0 0 248 249 u_system_devices_static_finalize( // 250 usysds, // usysds

··· 243 */ 244 245 xsysd->static_roles.head = ubrh.head; 246 + #define U_SET_HT_ROLE(SRC) \ 247 + xsysd->static_roles.hand_tracking.SRC.left = ubrh.hand_tracking.SRC.left; \ 248 + xsysd->static_roles.hand_tracking.SRC.right = ubrh.hand_tracking.SRC.right; 249 + U_SET_HT_ROLE(unobstructed) 250 + U_SET_HT_ROLE(conforming) 251 + #undef U_SET_HT_ROLE 252 253 u_system_devices_static_finalize( // 254 usysds, // usysds

+11 -2

src/xrt/auxiliary/util/u_builders.h

··· 89 90 struct 91 { 92 - struct xrt_device *left; 93 - struct xrt_device *right; 0 0 0 0 0 0 0 0 0 94 } hand_tracking; 95 }; 96

··· 89 90 struct 91 { 92 + struct 93 + { 94 + struct xrt_device *left; 95 + struct xrt_device *right; 96 + } unobstructed; 97 + 98 + struct 99 + { 100 + struct xrt_device *left; 101 + struct xrt_device *right; 102 + } conforming; 103 } hand_tracking; 104 }; 105

+51 -5

src/xrt/auxiliary/util/u_system_helpers.c

··· 55 } 56 } 57 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 58 59 /* 60 * ··· 95 return XRT_SUCCESS; 96 } 97 98 - xrt_result_t xret; 99 if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_LEFT) { 100 - xret = xrt_device_begin_feature(xsysd->static_roles.hand_tracking.left, type); 101 } else if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_RIGHT) { 102 - xret = xrt_device_begin_feature(xsysd->static_roles.hand_tracking.right, type); 103 } else if (type == XRT_DEVICE_FEATURE_EYE_TRACKING) { 104 xret = xrt_device_begin_feature(xsysd->static_roles.eyes, type); 105 } else { ··· 130 131 xrt_result_t xret; 132 if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_LEFT) { 133 - xret = xrt_device_end_feature(xsysd->static_roles.hand_tracking.left, type); 134 } else if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_RIGHT) { 135 - xret = xrt_device_end_feature(xsysd->static_roles.hand_tracking.right, type); 136 } else if (type == XRT_DEVICE_FEATURE_EYE_TRACKING) { 137 xret = xrt_device_end_feature(xsysd->static_roles.eyes, type); 138 } else {

··· 55 } 56 } 57 58 + static inline void 59 + get_hand_tracking_devices(struct xrt_system_devices *xsysd, enum xrt_hand hand, struct xrt_device *out_ht_xdevs[2]) 60 + { 61 + #define XRT_GET_U_HT(HAND) xsysd->static_roles.hand_tracking.unobstructed.HAND 62 + #define XRT_GET_C_HT(HAND) xsysd->static_roles.hand_tracking.conforming.HAND 63 + if (hand == XRT_HAND_LEFT) { 64 + out_ht_xdevs[0] = XRT_GET_U_HT(left); 65 + out_ht_xdevs[1] = XRT_GET_C_HT(left); 66 + } else { 67 + out_ht_xdevs[0] = XRT_GET_U_HT(right); 68 + out_ht_xdevs[1] = XRT_GET_C_HT(right); 69 + } 70 + #undef XRT_GET_C_HT 71 + #undef XRT_GET_U_HT 72 + } 73 + 74 + static xrt_result_t 75 + set_hand_tracking_enabled(struct xrt_system_devices *xsysd, enum xrt_hand hand, bool enable) 76 + { 77 + struct xrt_device *ht_sources[2] = {0}; 78 + get_hand_tracking_devices(xsysd, hand, ht_sources); 79 + 80 + uint32_t ht_sources_size = ARRAY_SIZE(ht_sources); 81 + // hand-tracking data-sources can all come from the same xrt-device instance 82 + if (ht_sources[0] == ht_sources[1]) { 83 + ht_sources_size = 1; 84 + } 85 + 86 + typedef xrt_result_t (*set_feature_t)(struct xrt_device *, enum xrt_device_feature_type); 87 + const set_feature_t set_feature = enable ? xrt_device_begin_feature : xrt_device_end_feature; 88 + 89 + const enum xrt_device_feature_type ht_feature = 90 + (hand == XRT_HAND_LEFT) ? XRT_DEVICE_FEATURE_HAND_TRACKING_LEFT : XRT_DEVICE_FEATURE_HAND_TRACKING_RIGHT; 91 + 92 + xrt_result_t xret = XRT_SUCCESS; 93 + for (uint32_t i = 0; i < ht_sources_size; ++i) { 94 + if (ht_sources[i]) { 95 + xret = set_feature(ht_sources[i], ht_feature); 96 + } 97 + if (xret != XRT_SUCCESS) { 98 + break; 99 + } 100 + } 101 + return xret; 102 + } 103 + 104 105 /* 106 * ··· 141 return XRT_SUCCESS; 142 } 143 144 + xrt_result_t xret = XRT_SUCCESS; 145 if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_LEFT) { 146 + xret = set_hand_tracking_enabled(xsysd, XRT_HAND_LEFT, true); 147 } else if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_RIGHT) { 148 + xret = set_hand_tracking_enabled(xsysd, XRT_HAND_RIGHT, true); 149 } else if (type == XRT_DEVICE_FEATURE_EYE_TRACKING) { 150 xret = xrt_device_begin_feature(xsysd->static_roles.eyes, type); 151 } else { ··· 176 177 xrt_result_t xret; 178 if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_LEFT) { 179 + xret = set_hand_tracking_enabled(xsysd, XRT_HAND_LEFT, false); 180 } else if (type == XRT_DEVICE_FEATURE_HAND_TRACKING_RIGHT) { 181 + xret = set_hand_tracking_enabled(xsysd, XRT_HAND_RIGHT, false); 182 } else if (type == XRT_DEVICE_FEATURE_EYE_TRACKING) { 183 xret = xrt_device_end_feature(xsysd->static_roles.eyes, type); 184 } else {

+29 -26

src/xrt/auxiliary/util/u_system_helpers.h

··· 185 u_system_devices_get_ht_device(struct xrt_system_devices *xsysd, enum xrt_input_name name); 186 187 /*! 188 - * Helper to get the first left hand-tracking device, 189 * uses @ref u_system_devices_get_ht_device. 190 * 191 * @ingroup aux_util 192 */ 193 static inline struct xrt_device * 194 - u_system_devices_get_ht_device_left(struct xrt_system_devices *xsysd) 195 { 196 - const enum xrt_input_name ht_input_names[2] = { 197 - XRT_INPUT_HT_UNOBSTRUCTED_LEFT, 198 - XRT_INPUT_HT_CONFORMING_LEFT, 199 - }; 200 - for (uint32_t i = 0; i < ARRAY_SIZE(ht_input_names); ++i) { 201 - struct xrt_device *xdev = u_system_devices_get_ht_device(xsysd, ht_input_names[i]); 202 - if (xdev != NULL) { 203 - return xdev; 204 - } 205 - } 206 - return NULL; 0 0 207 } 208 209 /*! 210 - * Helper to get the first right hand-tracking device, 211 * uses @ref u_system_devices_get_ht_device. 212 * 213 * @ingroup aux_util 214 */ 215 static inline struct xrt_device * 216 - u_system_devices_get_ht_device_right(struct xrt_system_devices *xsysd) 217 { 218 - const enum xrt_input_name ht_input_names[2] = { 219 - XRT_INPUT_HT_UNOBSTRUCTED_RIGHT, 220 - XRT_INPUT_HT_CONFORMING_RIGHT, 221 - }; 222 - for (uint32_t i = 0; i < ARRAY_SIZE(ht_input_names); ++i) { 223 - struct xrt_device *xdev = u_system_devices_get_ht_device(xsysd, ht_input_names[i]); 224 - if (xdev != NULL) { 225 - return xdev; 226 - } 227 - } 228 - return NULL; 229 } 230 0 0 0 0 0 0 0 0 0 0 0 231 232 #ifdef __cplusplus 233 }

··· 185 u_system_devices_get_ht_device(struct xrt_system_devices *xsysd, enum xrt_input_name name); 186 187 /*! 188 + * Helper to get the first left (unobstructed) hand-tracking device, 189 * uses @ref u_system_devices_get_ht_device. 190 * 191 * @ingroup aux_util 192 */ 193 static inline struct xrt_device * 194 + u_system_devices_get_ht_device_unobstructed_left(struct xrt_system_devices *xsysd) 195 { 196 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_LEFT); 197 + } 198 + 199 + /*! 200 + * Helper to get the first (unobstructed) right hand-tracking device, 201 + * uses @ref u_system_devices_get_ht_device. 202 + * 203 + * @ingroup aux_util 204 + */ 205 + static inline struct xrt_device * 206 + u_system_devices_get_ht_device_unobstructed_right(struct xrt_system_devices *xsysd) 207 + { 208 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); 209 } 210 211 /*! 212 + * Helper to get the first left (conforming) hand-tracking device, 213 * uses @ref u_system_devices_get_ht_device. 214 * 215 * @ingroup aux_util 216 */ 217 static inline struct xrt_device * 218 + u_system_devices_get_ht_device_conforming_left(struct xrt_system_devices *xsysd) 219 { 220 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_CONFORMING_LEFT); 0 0 0 0 0 0 0 0 0 0 221 } 222 223 + /*! 224 + * Helper to get the first (conforming) right hand-tracking device, 225 + * uses @ref u_system_devices_get_ht_device. 226 + * 227 + * @ingroup aux_util 228 + */ 229 + static inline struct xrt_device * 230 + u_system_devices_get_ht_device_conforming_right(struct xrt_system_devices *xsysd) 231 + { 232 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_CONFORMING_RIGHT); 233 + } 234 235 #ifdef __cplusplus 236 }

+2 -2

src/xrt/drivers/remote/r_hub.c

··· 473 r->base.xdevs[r->base.xdev_count++] = right; 474 475 r->base.static_roles.head = head; 476 - r->base.static_roles.hand_tracking.left = left; 477 - r->base.static_roles.hand_tracking.right = right; 478 479 480 /*

··· 473 r->base.xdevs[r->base.xdev_count++] = right; 474 475 r->base.static_roles.head = head; 476 + r->base.static_roles.hand_tracking.conforming.left = left; 477 + r->base.static_roles.hand_tracking.conforming.right = right; 478 479 480 /*

+39 -16

src/xrt/include/xrt/xrt_system.h

··· 273 */ 274 struct 275 { 0 0 0 0 0 0 0 0 0 0 276 277 - /*! 278 - * An observing pointer to the device providing hand 279 - * tracking for the left hand (optional). 280 - * 281 - * Currently this is used for both optical and 282 - * controller driven hand-tracking. 283 - */ 284 - struct xrt_device *left; 0 0 0 0 0 0 0 0 0 0 0 0 285 286 - /*! 287 - * An observing pointer to the device providing hand 288 - * tracking for the right hand (optional). 289 - * 290 - * Currently this is used for both optical and 291 - * controller driven hand-tracking. 292 - */ 293 - struct xrt_device *right; 0 294 } hand_tracking; 295 } static_roles; 296

··· 273 */ 274 struct 275 { 276 + struct 277 + { 278 + /*! 279 + * An observing pointer to the device providing 280 + * unobstructed hand-tracking for the left hand (optional). 281 + * 282 + * can reference the same xrt_device instance as 283 + * @ref hand_tracking::conforming::left, if provides both input types. 284 + */ 285 + struct xrt_device *left; 286 287 + /*! 288 + * An observing pointer to the device providing 289 + * unobstructed hand-tracking for the right hand (optional). 290 + * 291 + * can reference the same xrt_device instance as 292 + * @ref hand_tracking::conforming::right, if provides both input types. 293 + */ 294 + struct xrt_device *right; 295 + } unobstructed; 296 + 297 + struct 298 + { 299 + /*! 300 + * An observing pointer to the device providing 301 + * conforming (controller) hand-tracking for the left hand (optional). 302 + * 303 + * can reference the same xrt_device instance as 304 + * @ref hand_tracking::unobstructed::left, if provides both input types. 305 + */ 306 + struct xrt_device *left; 307 308 + /*! 309 + * An observing pointer to the device providing 310 + * conforming (controller) hand-tracking for the right hand (optional). 311 + * 312 + * can reference the same xrt_device instance as 313 + * @ref hand_tracking::unobstructed::right, if provides both input types. 314 + */ 315 + struct xrt_device *right; 316 + } conforming; 317 } hand_tracking; 318 } static_roles; 319

+4 -2

src/xrt/ipc/client/ipc_client_instance.c

··· 175 SET_ROLE(eyes); 176 SET_ROLE(face); 177 SET_ROLE(body); 178 - SET_ROLE(hand_tracking.left); 179 - SET_ROLE(hand_tracking.right); 0 0 180 181 #undef SET_ROLE 182

··· 175 SET_ROLE(eyes); 176 SET_ROLE(face); 177 SET_ROLE(body); 178 + SET_ROLE(hand_tracking.unobstructed.left); 179 + SET_ROLE(hand_tracking.unobstructed.right); 180 + SET_ROLE(hand_tracking.conforming.left); 181 + SET_ROLE(hand_tracking.conforming.right); 182 183 #undef SET_ROLE 184

+6 -2

src/xrt/ipc/server/ipc_server_process.c

··· 430 ism->roles.eyes = find_xdev_index(s, s->xsysd->static_roles.eyes); 431 ism->roles.face = find_xdev_index(s, s->xsysd->static_roles.face); 432 ism->roles.body = find_xdev_index(s, s->xsysd->static_roles.body); 433 - ism->roles.hand_tracking.left = find_xdev_index(s, s->xsysd->static_roles.hand_tracking.left); 434 - ism->roles.hand_tracking.right = find_xdev_index(s, s->xsysd->static_roles.hand_tracking.right); 0 0 0 0 435 436 // Fill out git version info. 437 snprintf(s->ism->u_git_tag, IPC_VERSION_NAME_LEN, "%s", u_git_tag);

··· 430 ism->roles.eyes = find_xdev_index(s, s->xsysd->static_roles.eyes); 431 ism->roles.face = find_xdev_index(s, s->xsysd->static_roles.face); 432 ism->roles.body = find_xdev_index(s, s->xsysd->static_roles.body); 433 + #define SET_HT_ROLE(SRC) \ 434 + ism->roles.hand_tracking.SRC.left = find_xdev_index(s, s->xsysd->static_roles.hand_tracking.SRC.left); \ 435 + ism->roles.hand_tracking.SRC.right = find_xdev_index(s, s->xsysd->static_roles.hand_tracking.SRC.right); 436 + SET_HT_ROLE(unobstructed) 437 + SET_HT_ROLE(conforming) 438 + #undef SET_HT_ROLE 439 440 // Fill out git version info. 441 snprintf(s->ism->u_git_tag, IPC_VERSION_NAME_LEN, "%s", u_git_tag);

+12 -3

src/xrt/ipc/shared/ipc_protocol.h

··· 244 245 struct 246 { 247 - int32_t left; 248 - int32_t right; 0 0 0 0 0 0 0 0 0 249 } hand_tracking; 250 } roles; 251 ··· 291 struct xrt_plane_detector_begin_info_ext plane_begin_info_ext; 292 }; 293 294 - static_assert(sizeof(struct ipc_shared_memory) == 6500048, 295 "invalid structure size, maybe different 32/64 bits sizes or padding"); 296 297 /*!

··· 244 245 struct 246 { 247 + struct 248 + { 249 + int32_t left; 250 + int32_t right; 251 + } unobstructed; 252 + 253 + struct 254 + { 255 + int32_t left; 256 + int32_t right; 257 + } conforming; 258 } hand_tracking; 259 } roles; 260 ··· 300 struct xrt_plane_detector_begin_info_ext plane_begin_info_ext; 301 }; 302 303 + static_assert(sizeof(struct ipc_shared_memory) == 6500056, 304 "invalid structure size, maybe different 32/64 bits sizes or padding"); 305 306 /*!

+29 -38

src/xrt/state_trackers/oxr/oxr_api_session.c

··· 431 hand_tracker->hand = createInfo->hand; 432 hand_tracker->hand_joint_set = createInfo->handJointSet; 433 434 - // Find the assigned device. 435 - struct xrt_device *xdev = NULL; 436 - if (createInfo->hand == XR_HAND_LEFT_EXT) { 437 - xdev = GET_XDEV_BY_ROLE(sess->sys, hand_tracking_left); 438 - } else if (createInfo->hand == XR_HAND_RIGHT_EXT) { 439 - xdev = GET_XDEV_BY_ROLE(sess->sys, hand_tracking_right); 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 440 } 441 442 - // Find the correct input on the device. 443 - if (xdev != NULL && xdev->supported.hand_tracking) { 444 - for (uint32_t j = 0; j < xdev->input_count; j++) { 445 - const struct xrt_input *input = &xdev->inputs[j]; 446 - 447 - if ((input->name == XRT_INPUT_HT_UNOBSTRUCTED_LEFT && createInfo->hand == XR_HAND_LEFT_EXT) || 448 - (input->name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT && createInfo->hand == XR_HAND_RIGHT_EXT)) { 449 - hand_tracker->xdev = xdev; 450 - hand_tracker->input_name = input->name; 451 - break; 452 - } 453 - } 454 - if (hand_tracker->xdev == NULL) { 455 - for (uint32_t j = 0; j < xdev->input_count; j++) { 456 - const struct xrt_input *input = &xdev->inputs[j]; 457 - 458 - if ((input->name == XRT_INPUT_HT_CONFORMING_LEFT && 459 - createInfo->hand == XR_HAND_LEFT_EXT) || 460 - (input->name == XRT_INPUT_HT_CONFORMING_RIGHT && 461 - createInfo->hand == XR_HAND_RIGHT_EXT)) { 462 - hand_tracker->xdev = xdev; 463 - hand_tracker->input_name = input->name; 464 - break; 465 - } 466 - } 467 - } 468 - } 469 - 470 - // Consistency checking. 471 - if (xdev != NULL && hand_tracker->xdev == NULL) { 472 - oxr_warn(log, "We got hand tracking xdev but it didn't have a hand tracking input."); 473 - } 474 475 *out_hand_tracker = hand_tracker; 476

··· 431 hand_tracker->hand = createInfo->hand; 432 hand_tracker->hand_joint_set = createInfo->handJointSet; 433 434 + #define OXR_SET_HT_DATA_SOURCE(SRC, SRC_TYPE) \ 435 + { \ 436 + struct xrt_device *xdev = NULL; \ 437 + if (createInfo->hand == XR_HAND_LEFT_EXT) { \ 438 + xdev = GET_XDEV_BY_ROLE(sess->sys, hand_tracking_##SRC##_left); \ 439 + } else if (createInfo->hand == XR_HAND_RIGHT_EXT) { \ 440 + xdev = GET_XDEV_BY_ROLE(sess->sys, hand_tracking_##SRC##_right); \ 441 + } \ 442 + \ 443 + if (xdev != NULL && xdev->supported.hand_tracking) { \ 444 + const enum xrt_input_name ht_input_name = createInfo->hand == XR_HAND_LEFT_EXT \ 445 + ? XRT_INPUT_HT_##SRC_TYPE##_LEFT \ 446 + : XRT_INPUT_HT_##SRC_TYPE##_RIGHT; \ 447 + struct xrt_input *input = NULL; \ 448 + if (oxr_xdev_find_input(xdev, ht_input_name, &input) && input != NULL) { \ 449 + hand_tracker->SRC = (struct oxr_hand_tracking_data_source){ \ 450 + .xdev = xdev, \ 451 + .input_name = ht_input_name, \ 452 + }; \ 453 + } \ 454 + } \ 455 + \ 456 + if (xdev != NULL && hand_tracker->SRC.xdev == NULL) \ 457 + oxr_warn(log, "We got hand tracking xdev (%s) but it didn't have a hand tracking input.", \ 458 + #SRC); \ 459 } 460 461 + // Find the assigned device. 462 + OXR_SET_HT_DATA_SOURCE(unobstructed, UNOBSTRUCTED) 463 + OXR_SET_HT_DATA_SOURCE(conforming, CONFORMING) 464 + #undef OXR_SET_HT_DATA_SOURCE 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 465 466 *out_hand_tracker = hand_tracker; 467

+9 -5

src/xrt/state_trackers/oxr/oxr_instance.c

··· 145 // Static roles. 146 struct xrt_device *h = GET_XDEV_BY_ROLE(sys, head); 147 struct xrt_device *e = GET_XDEV_BY_ROLE(sys, eyes); 148 - struct xrt_device *hl = GET_XDEV_BY_ROLE(sys, hand_tracking_left); 149 - struct xrt_device *hr = GET_XDEV_BY_ROLE(sys, hand_tracking_right); 0 0 150 151 // Dynamic roles, the system cache might not have been updated yet. 152 struct xrt_system_roles roles = XRT_SYSTEM_ROLES_INIT; ··· 163 "\n\tLeft: '%s'" 164 "\n\tRight: '%s'" 165 "\n\tGamepad: '%s'" 166 - "\n\tHand-Tracking Left: '%s'" 167 - "\n\tHand-Tracking Right: '%s'", 168 - P(h), P(e), P(l), P(r), P(gp), P(hl), P(hr)); 0 0 169 170 #undef P 171 #undef D

··· 145 // Static roles. 146 struct xrt_device *h = GET_XDEV_BY_ROLE(sys, head); 147 struct xrt_device *e = GET_XDEV_BY_ROLE(sys, eyes); 148 + struct xrt_device *uhl = GET_XDEV_BY_ROLE(sys, hand_tracking_unobstructed_left); 149 + struct xrt_device *uhr = GET_XDEV_BY_ROLE(sys, hand_tracking_unobstructed_right); 150 + struct xrt_device *chl = GET_XDEV_BY_ROLE(sys, hand_tracking_conforming_left); 151 + struct xrt_device *chr = GET_XDEV_BY_ROLE(sys, hand_tracking_conforming_right); 152 153 // Dynamic roles, the system cache might not have been updated yet. 154 struct xrt_system_roles roles = XRT_SYSTEM_ROLES_INIT; ··· 165 "\n\tLeft: '%s'" 166 "\n\tRight: '%s'" 167 "\n\tGamepad: '%s'" 168 + "\n\tHand-Tracking Left (unobstructed): '%s'" 169 + "\n\tHand-Tracking Right (unobstructed): '%s'" 170 + "\n\tHand-Tracking Left (conforming): '%s'" 171 + "\n\tHand-Tracking Right (conforming): '%s'", 172 + P(h), P(e), P(l), P(r), P(gp), P(uhl), P(uhr), P(chl), P(chr)); 173 174 #undef P 175 #undef D

+29 -9

src/xrt/state_trackers/oxr/oxr_objects.h

··· 1555 static inline struct xrt_device *get_role_eyes(struct oxr_system *sys) {return sys->xsysd->static_roles.eyes; } 1556 static inline struct xrt_device *get_role_face(struct oxr_system* sys) { return sys->xsysd->static_roles.face; } 1557 static inline struct xrt_device *get_role_body(struct oxr_system* sys) { return sys->xsysd->static_roles.body; } 1558 - static inline struct xrt_device *get_role_hand_tracking_left(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.left; } 1559 - static inline struct xrt_device *get_role_hand_tracking_right(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.right; } 0 0 0 1560 // clang-format on 1561 1562 // dynamic roles ··· 1601 return XRT_DEVICE_INVALID; 1602 } 1603 static inline enum xrt_device_name 1604 - get_role_profile_hand_tracking_left(struct oxr_system *sys) 0 0 0 0 0 0 0 0 0 0 0 1605 { 1606 return XRT_DEVICE_INVALID; 1607 } 1608 static inline enum xrt_device_name 1609 - get_role_profile_hand_tracking_right(struct oxr_system *sys) 1610 { 1611 return XRT_DEVICE_INVALID; 1612 } ··· 2631 void *XR_MAY_ALIAS user_data; 2632 }; 2633 0 0 0 0 0 0 0 0 0 2634 /*! 2635 * A hand tracker. 2636 * ··· 2648 //! Owner of this hand tracker. 2649 struct oxr_session *sess; 2650 2651 - //! xrt_device backing this hand tracker 2652 - struct xrt_device *xdev; 2653 - 2654 - //! the input name associated with this hand tracker 2655 - enum xrt_input_name input_name; 2656 2657 XrHandEXT hand; 2658 XrHandJointSetEXT hand_joint_set;

··· 1555 static inline struct xrt_device *get_role_eyes(struct oxr_system *sys) {return sys->xsysd->static_roles.eyes; } 1556 static inline struct xrt_device *get_role_face(struct oxr_system* sys) { return sys->xsysd->static_roles.face; } 1557 static inline struct xrt_device *get_role_body(struct oxr_system* sys) { return sys->xsysd->static_roles.body; } 1558 + static inline struct xrt_device *get_role_hand_tracking_unobstructed_left(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.unobstructed.left; } 1559 + static inline struct xrt_device *get_role_hand_tracking_unobstructed_right(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.unobstructed.right; } 1560 + static inline struct xrt_device *get_role_hand_tracking_conforming_left(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.conforming.left; } 1561 + static inline struct xrt_device *get_role_hand_tracking_conforming_right(struct oxr_system* sys) { return sys->xsysd->static_roles.hand_tracking.conforming.right; } 1562 + 1563 // clang-format on 1564 1565 // dynamic roles ··· 1604 return XRT_DEVICE_INVALID; 1605 } 1606 static inline enum xrt_device_name 1607 + get_role_profile_hand_tracking_unobstructed_left(struct oxr_system *sys) 1608 + { 1609 + return XRT_DEVICE_INVALID; 1610 + } 1611 + static inline enum xrt_device_name 1612 + get_role_profile_hand_tracking_unobstructed_right(struct oxr_system *sys) 1613 + { 1614 + return XRT_DEVICE_INVALID; 1615 + } 1616 + 1617 + static inline enum xrt_device_name 1618 + get_role_profile_hand_tracking_conforming_left(struct oxr_system *sys) 1619 { 1620 return XRT_DEVICE_INVALID; 1621 } 1622 static inline enum xrt_device_name 1623 + get_role_profile_hand_tracking_conforming_right(struct oxr_system *sys) 1624 { 1625 return XRT_DEVICE_INVALID; 1626 } ··· 2645 void *XR_MAY_ALIAS user_data; 2646 }; 2647 2648 + struct oxr_hand_tracking_data_source 2649 + { 2650 + //! xrt_device backing this hand tracker 2651 + struct xrt_device *xdev; 2652 + 2653 + //! the input name associated with this hand tracker 2654 + enum xrt_input_name input_name; 2655 + }; 2656 + 2657 /*! 2658 * A hand tracker. 2659 * ··· 2671 //! Owner of this hand tracker. 2672 struct oxr_session *sess; 2673 2674 + struct oxr_hand_tracking_data_source unobstructed; 2675 + struct oxr_hand_tracking_data_source conforming; 0 0 0 2676 2677 XrHandEXT hand; 2678 XrHandJointSetEXT hand_joint_set;

+45 -19

src/xrt/state_trackers/oxr/oxr_session.c

··· 55 DEBUG_GET_ONCE_NUM_OPTION(ipd, "OXR_DEBUG_IPD_MM", 63) 56 DEBUG_GET_ONCE_NUM_OPTION(wait_frame_sleep, "OXR_DEBUG_WAIT_FRAME_EXTRA_SLEEP_MS", 0) 57 DEBUG_GET_ONCE_BOOL_OPTION(frame_timing_spew, "OXR_FRAME_TIMING_SPEW", false) 0 58 59 60 /* ··· 1314 XrHandJointVelocitiesEXT *vel = 1315 OXR_GET_OUTPUT_FROM_CHAIN(locations, XR_TYPE_HAND_JOINT_VELOCITIES_EXT, XrHandJointVelocitiesEXT); 1316 1317 - if (hand_tracker->xdev == NULL) { 1318 - locations->isActive = false; 1319 - return XR_SUCCESS; 1320 - } 1321 1322 - struct xrt_device *xdev = hand_tracker->xdev; 1323 - enum xrt_input_name name = hand_tracker->input_name; 1324 1325 - XrTime at_time = locateInfo->time; 1326 - 1327 - //! Convert at_time to monotonic and give to device. 1328 - int64_t at_timestamp_ns = time_state_ts_to_monotonic_ns(inst->timekeeping, at_time); 0 0 0 0 0 1329 1330 struct xrt_hand_joint_set value; 1331 - int64_t ignored; 0 0 0 0 0 0 0 0 0 0 0 0 0 1332 1333 - xrt_result_t xret = xrt_device_get_hand_tracking(xdev, name, at_timestamp_ns, &value, &ignored); 1334 - OXR_CHECK_XRET(log, sess, xret, xrt_device_get_hand_tracking); 0 0 1335 1336 // The hand pose is returned in the xdev's space. 1337 struct xrt_space_relation T_xdev_hand = value.hand_pose; ··· 1339 // Get the xdev's pose in the base space. 1340 struct xrt_space_relation T_base_xdev = XRT_SPACE_RELATION_ZERO; 1341 1342 - XrResult ret = oxr_space_locate_device(log, xdev, baseSpc, at_time, &T_base_xdev); 1343 if (ret != XR_SUCCESS) { 1344 // Error printed logged oxr_space_locate_device 1345 return ret; ··· 1465 struct oxr_hand_tracker *hand_tracker, 1466 const XrForceFeedbackCurlApplyLocationsMNDX *locations) 1467 { 1468 - struct xrt_device *xdev = hand_tracker->xdev; 1469 - 1470 struct xrt_output_value result = {0}; 1471 result.type = XRT_OUTPUT_VALUE_TYPE_FORCE_FEEDBACK; 1472 result.force_feedback.force_feedback_location_count = locations->locationCount; ··· 1476 result.force_feedback.force_feedback[i].value = locations->locations[i].value; 1477 } 1478 1479 - xrt_result_t xret = xrt_device_set_output(xdev, xr_hand_to_force_feedback_output(hand_tracker->hand), &result); 1480 - if (xret != XRT_SUCCESS) { 1481 - return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "xr_device_set_output failed"); 0 0 0 0 0 0 0 0 0 0 1482 } 1483 1484 return XR_SUCCESS;

··· 55 DEBUG_GET_ONCE_NUM_OPTION(ipd, "OXR_DEBUG_IPD_MM", 63) 56 DEBUG_GET_ONCE_NUM_OPTION(wait_frame_sleep, "OXR_DEBUG_WAIT_FRAME_EXTRA_SLEEP_MS", 0) 57 DEBUG_GET_ONCE_BOOL_OPTION(frame_timing_spew, "OXR_FRAME_TIMING_SPEW", false) 58 + DEBUG_GET_ONCE_BOOL_OPTION(hand_tracking_prioritize_conforming, "OXR_HAND_TRACKING_PRIORITIZE_CONFORMING", false) 59 60 61 /* ··· 1315 XrHandJointVelocitiesEXT *vel = 1316 OXR_GET_OUTPUT_FROM_CHAIN(locations, XR_TYPE_HAND_JOINT_VELOCITIES_EXT, XrHandJointVelocitiesEXT); 1317 1318 + const XrTime at_time = locateInfo->time; 0 0 0 1319 1320 + //! Convert at_time to monotonic and give to device. 1321 + const int64_t at_timestamp_ns = time_state_ts_to_monotonic_ns(inst->timekeeping, at_time); 1322 1323 + const struct oxr_hand_tracking_data_source *data_sources[2] = { 1324 + &hand_tracker->unobstructed, 1325 + &hand_tracker->conforming, 1326 + }; 1327 + if (debug_get_bool_option_hand_tracking_prioritize_conforming()) { 1328 + const struct oxr_hand_tracking_data_source *tmp = data_sources[0]; 1329 + data_sources[0] = data_sources[1]; 1330 + data_sources[1] = tmp; 1331 + } 1332 1333 struct xrt_hand_joint_set value; 1334 + const struct oxr_hand_tracking_data_source *data_source = NULL; 1335 + for (uint32_t i = 0; i < ARRAY_SIZE(data_sources); ++i) { 1336 + data_source = data_sources[i]; 1337 + if (data_source->xdev == NULL) 1338 + continue; 1339 + int64_t ignored; 1340 + value = (struct xrt_hand_joint_set){0}; 1341 + xrt_result_t xret = xrt_device_get_hand_tracking(data_source->xdev, data_source->input_name, 1342 + at_timestamp_ns, &value, &ignored); 1343 + OXR_CHECK_XRET(log, sess, xret, xrt_device_get_hand_tracking); 1344 + if (value.is_active) { 1345 + break; 1346 + } 1347 + } 1348 1349 + if (data_source == NULL || data_source->xdev == NULL) { 1350 + locations->isActive = false; 1351 + return XR_SUCCESS; 1352 + } 1353 1354 // The hand pose is returned in the xdev's space. 1355 struct xrt_space_relation T_xdev_hand = value.hand_pose; ··· 1357 // Get the xdev's pose in the base space. 1358 struct xrt_space_relation T_base_xdev = XRT_SPACE_RELATION_ZERO; 1359 1360 + XrResult ret = oxr_space_locate_device(log, data_source->xdev, baseSpc, at_time, &T_base_xdev); 1361 if (ret != XR_SUCCESS) { 1362 // Error printed logged oxr_space_locate_device 1363 return ret; ··· 1483 struct oxr_hand_tracker *hand_tracker, 1484 const XrForceFeedbackCurlApplyLocationsMNDX *locations) 1485 { 0 0 1486 struct xrt_output_value result = {0}; 1487 result.type = XRT_OUTPUT_VALUE_TYPE_FORCE_FEEDBACK; 1488 result.force_feedback.force_feedback_location_count = locations->locationCount; ··· 1492 result.force_feedback.force_feedback[i].value = locations->locations[i].value; 1493 } 1494 1495 + const struct oxr_hand_tracking_data_source *data_sources[2] = { 1496 + &hand_tracker->unobstructed, 1497 + &hand_tracker->conforming, 1498 + }; 1499 + for (uint32_t i = 0; i < ARRAY_SIZE(data_sources); ++i) { 1500 + struct xrt_device *xdev = data_sources[i]->xdev; 1501 + if (xdev) { 1502 + xrt_result_t xret = 1503 + xrt_device_set_output(xdev, xr_hand_to_force_feedback_output(hand_tracker->hand), &result); 1504 + if (xret != XRT_SUCCESS) { 1505 + return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "xr_device_set_output failed"); 1506 + } 1507 + } 1508 } 1509 1510 return XR_SUCCESS;

+26 -14

src/xrt/state_trackers/oxr/oxr_system.c

··· 249 oxr_system_get_hand_tracking_support(struct oxr_logger *log, struct oxr_instance *inst) 250 { 251 struct oxr_system *sys = &inst->system; 252 - struct xrt_device *ht_left = GET_XDEV_BY_ROLE(sys, hand_tracking_left); 253 - struct xrt_device *ht_right = GET_XDEV_BY_ROLE(sys, hand_tracking_right); 254 - 255 - bool left_supported = ht_left && ht_left->supported.hand_tracking; 256 - bool right_supported = ht_right && ht_right->supported.hand_tracking; 257 - 258 - return left_supported || right_supported; 0 0 0 0 0 0 259 } 260 261 bool ··· 271 oxr_system_get_force_feedback_support(struct oxr_logger *log, struct oxr_instance *inst) 272 { 273 struct oxr_system *sys = &inst->system; 274 - struct xrt_device *ffb_left = GET_XDEV_BY_ROLE(sys, hand_tracking_left); 275 - struct xrt_device *ffb_right = GET_XDEV_BY_ROLE(sys, hand_tracking_right); 276 - 277 - bool left_supported = ffb_left && ffb_left->supported.force_feedback; 278 - bool right_supported = ffb_right && ffb_right->supported.force_feedback; 279 - 280 - return left_supported || right_supported; 0 0 0 0 0 0 281 } 282 283 void

··· 249 oxr_system_get_hand_tracking_support(struct oxr_logger *log, struct oxr_instance *inst) 250 { 251 struct oxr_system *sys = &inst->system; 252 + #define OXR_CHECK_RET_IS_HT_SUPPORTED(HT_ROLE) \ 253 + { \ 254 + const struct xrt_device *ht = GET_XDEV_BY_ROLE(sys, hand_tracking_##HT_ROLE); \ 255 + if (ht && ht->supported.hand_tracking) { \ 256 + return true; \ 257 + } \ 258 + } 259 + OXR_CHECK_RET_IS_HT_SUPPORTED(unobstructed_left) 260 + OXR_CHECK_RET_IS_HT_SUPPORTED(unobstructed_right) 261 + OXR_CHECK_RET_IS_HT_SUPPORTED(conforming_left) 262 + OXR_CHECK_RET_IS_HT_SUPPORTED(conforming_right) 263 + #undef OXR_CHECK_RET_IS_HT_SUPPORTED 264 + return false; 265 } 266 267 bool ··· 277 oxr_system_get_force_feedback_support(struct oxr_logger *log, struct oxr_instance *inst) 278 { 279 struct oxr_system *sys = &inst->system; 280 + #define OXR_CHECK_RET_IS_FFB_SUPPORTED(HT_ROLE) \ 281 + { \ 282 + const struct xrt_device *ffb = GET_XDEV_BY_ROLE(sys, hand_tracking_##HT_ROLE); \ 283 + if (ffb && ffb->supported.force_feedback) { \ 284 + return true; \ 285 + } \ 286 + } 287 + OXR_CHECK_RET_IS_FFB_SUPPORTED(unobstructed_left) 288 + OXR_CHECK_RET_IS_FFB_SUPPORTED(unobstructed_right) 289 + OXR_CHECK_RET_IS_FFB_SUPPORTED(conforming_left) 290 + OXR_CHECK_RET_IS_FFB_SUPPORTED(conforming_right) 291 + #undef OXR_CHECK_RET_IS_FFB_SUPPORTED 292 + return false; 293 } 294 295 void

+4 -2

src/xrt/state_trackers/prober/p_prober.c

··· 868 PD(left); 869 PD(right); 870 PD(gamepad); 871 - P(hand_tracking.left); 872 - P(hand_tracking.right); 0 0 873 874 #undef P 875 #undef PD

··· 868 PD(left); 869 PD(right); 870 PD(gamepad); 871 + P(hand_tracking.unobstructed.left); 872 + P(hand_tracking.unobstructed.right); 873 + P(hand_tracking.conforming.left); 874 + P(hand_tracking.conforming.right); 875 876 #undef P 877 #undef PD

+4 -3

src/xrt/targets/cli/cli_cmd_test.c

··· 138 PRINT_DYNR(left, " "); 139 PRINT_DYNR(right, " "); 140 PRINT_DYNR(gamepad, " "); 141 - PRINT_ROLE(hand_tracking.left, " "); 142 - PRINT_ROLE(hand_tracking.right, ""); 143 - 0 144 145 // End of program 146 printf(" :: All ok, shutting down.\n");

··· 138 PRINT_DYNR(left, " "); 139 PRINT_DYNR(right, " "); 140 PRINT_DYNR(gamepad, " "); 141 + PRINT_ROLE(hand_tracking.unobstructed.left, " "); 142 + PRINT_ROLE(hand_tracking.unobstructed.right, ""); 143 + PRINT_ROLE(hand_tracking.conforming.left, " "); 144 + PRINT_ROLE(hand_tracking.conforming.right, ""); 145 146 // End of program 147 printf(" :: All ok, shutting down.\n");

+11 -5

src/xrt/targets/common/target_builder_legacy.c

··· 156 157 struct xrt_device *head = NULL; 158 struct xrt_device *left = NULL, *right = NULL, *gamepad = NULL; 159 - struct xrt_device *left_ht = NULL, *right_ht = NULL; 0 160 161 if (head_idx >= 0) { 162 head = xsysd->xdevs[head_idx]; ··· 172 } 173 174 // Find hand tracking devices. 175 - left_ht = u_system_devices_get_ht_device_left(xsysd); 176 - right_ht = u_system_devices_get_ht_device_right(xsysd); 0 0 0 177 178 // Assign to role(s). 179 ubrh->head = head; 180 ubrh->left = left; 181 ubrh->right = right; 182 ubrh->gamepad = gamepad; 183 - ubrh->hand_tracking.left = left_ht; 184 - ubrh->hand_tracking.right = right_ht; 0 0 185 186 return XRT_SUCCESS; 187 }

··· 156 157 struct xrt_device *head = NULL; 158 struct xrt_device *left = NULL, *right = NULL, *gamepad = NULL; 159 + struct xrt_device *unobstructed_left_ht = NULL, *unobstructed_right_ht = NULL; 160 + struct xrt_device *conforming_left_ht = NULL, *conforming_right_ht = NULL; 161 162 if (head_idx >= 0) { 163 head = xsysd->xdevs[head_idx]; ··· 173 } 174 175 // Find hand tracking devices. 176 + unobstructed_left_ht = u_system_devices_get_ht_device_unobstructed_left(xsysd); 177 + unobstructed_right_ht = u_system_devices_get_ht_device_unobstructed_right(xsysd); 178 + 179 + conforming_left_ht = u_system_devices_get_ht_device_conforming_left(xsysd); 180 + conforming_right_ht = u_system_devices_get_ht_device_conforming_right(xsysd); 181 182 // Assign to role(s). 183 ubrh->head = head; 184 ubrh->left = left; 185 ubrh->right = right; 186 ubrh->gamepad = gamepad; 187 + ubrh->hand_tracking.unobstructed.left = unobstructed_left_ht; 188 + ubrh->hand_tracking.unobstructed.right = unobstructed_right_ht; 189 + ubrh->hand_tracking.conforming.left = conforming_left_ht; 190 + ubrh->hand_tracking.conforming.right = conforming_right_ht; 191 192 return XRT_SUCCESS; 193 }

+13 -8

src/xrt/targets/common/target_builder_lighthouse.c

··· 635 // Devices to populate. 636 struct xrt_device *head = NULL; 637 struct xrt_device *left = NULL, *right = NULL; 638 - struct xrt_device *left_ht = NULL, *right_ht = NULL; 0 639 640 // Always have a head. 641 head = xsysd->xdevs[head_idx]; ··· 644 if (left_idx >= 0) { 645 lhs->vive_tstatus.controllers_found = true; 646 left = xsysd->xdevs[left_idx]; 647 - left_ht = u_system_devices_get_ht_device_left(xsysd); 0 648 } 649 650 if (right_idx >= 0) { 651 lhs->vive_tstatus.controllers_found = true; 652 right = xsysd->xdevs[right_idx]; 653 - right_ht = u_system_devices_get_ht_device_right(xsysd); 0 654 } 655 656 if (lhs->is_valve_index) { ··· 708 if (hand_devices[0] != NULL) { 709 xsysd->xdevs[xsysd->xdev_count++] = hand_devices[0]; 710 left = hand_devices[0]; 711 - left_ht = hand_devices[0]; 712 } 713 714 if (hand_devices[1] != NULL) { 715 xsysd->xdevs[xsysd->xdev_count++] = hand_devices[1]; 716 right = hand_devices[1]; 717 - right_ht = hand_devices[1]; 718 } 719 } 720 ··· 734 // Should we use OpenGloves. 735 if (!lhs->vive_tstatus.hand_enabled) { 736 // We only want to try to add opengloves if we aren't optically tracking hands 737 - try_add_opengloves(left, right, &left_ht, &right_ht); 738 } 739 740 // Assign to role(s). 741 ubrh->head = head; 742 ubrh->left = left; 743 ubrh->right = right; 744 - ubrh->hand_tracking.left = left_ht; 745 - ubrh->hand_tracking.right = right_ht; 0 0 746 747 // Clean up after us. 748 lhs->xfctx = NULL;

··· 635 // Devices to populate. 636 struct xrt_device *head = NULL; 637 struct xrt_device *left = NULL, *right = NULL; 638 + struct xrt_device *unobstructed_left_ht = NULL, *unobstructed_right_ht = NULL; 639 + struct xrt_device *conforming_left_ht = NULL, *conforming_right_ht = NULL; 640 641 // Always have a head. 642 head = xsysd->xdevs[head_idx]; ··· 645 if (left_idx >= 0) { 646 lhs->vive_tstatus.controllers_found = true; 647 left = xsysd->xdevs[left_idx]; 648 + unobstructed_left_ht = u_system_devices_get_ht_device_unobstructed_left(xsysd); 649 + conforming_left_ht = u_system_devices_get_ht_device_conforming_left(xsysd); 650 } 651 652 if (right_idx >= 0) { 653 lhs->vive_tstatus.controllers_found = true; 654 right = xsysd->xdevs[right_idx]; 655 + unobstructed_right_ht = u_system_devices_get_ht_device_unobstructed_right(xsysd); 656 + conforming_right_ht = u_system_devices_get_ht_device_conforming_right(xsysd); 657 } 658 659 if (lhs->is_valve_index) { ··· 711 if (hand_devices[0] != NULL) { 712 xsysd->xdevs[xsysd->xdev_count++] = hand_devices[0]; 713 left = hand_devices[0]; 714 + conforming_left_ht = hand_devices[0]; 715 } 716 717 if (hand_devices[1] != NULL) { 718 xsysd->xdevs[xsysd->xdev_count++] = hand_devices[1]; 719 right = hand_devices[1]; 720 + conforming_right_ht = hand_devices[1]; 721 } 722 } 723 ··· 737 // Should we use OpenGloves. 738 if (!lhs->vive_tstatus.hand_enabled) { 739 // We only want to try to add opengloves if we aren't optically tracking hands 740 + try_add_opengloves(left, right, &unobstructed_left_ht, &unobstructed_right_ht); 741 } 742 743 // Assign to role(s). 744 ubrh->head = head; 745 ubrh->left = left; 746 ubrh->right = right; 747 + ubrh->hand_tracking.unobstructed.left = unobstructed_left_ht; 748 + ubrh->hand_tracking.unobstructed.right = unobstructed_right_ht; 749 + ubrh->hand_tracking.conforming.left = conforming_left_ht; 750 + ubrh->hand_tracking.conforming.right = conforming_right_ht; 751 752 // Clean up after us. 753 lhs->xfctx = NULL;

+2 -2

src/xrt/targets/common/target_builder_north_star.c

··· 588 ubrh->head = head_wrap; 589 ubrh->left = left; 590 ubrh->right = right; 591 - ubrh->hand_tracking.left = left_ht; 592 - ubrh->hand_tracking.right = right_ht; 593 594 end: 595 if (nsb->config_json != NULL) {

··· 588 ubrh->head = head_wrap; 589 ubrh->left = left; 590 ubrh->right = right; 591 + ubrh->hand_tracking.unobstructed.left = left_ht; 592 + ubrh->hand_tracking.unobstructed.right = right_ht; 593 594 end: 595 if (nsb->config_json != NULL) {

+2 -2

src/xrt/targets/common/target_builder_rift_s.c

··· 204 ubrh->head = hmd_xdev; 205 ubrh->left = left_xdev; 206 ubrh->right = right_xdev; 207 - ubrh->hand_tracking.left = left_ht; 208 - ubrh->hand_tracking.right = right_ht; 209 210 return XRT_SUCCESS; 211

··· 204 ubrh->head = hmd_xdev; 205 ubrh->left = left_xdev; 206 ubrh->right = right_xdev; 207 + ubrh->hand_tracking.unobstructed.left = left_ht; 208 + ubrh->hand_tracking.unobstructed.right = right_ht; 209 210 return XRT_SUCCESS; 211

+21 -6

src/xrt/targets/common/target_builder_steamvr.c

··· 74 struct xrt_builder base; 75 76 struct xrt_device *head; 77 - struct xrt_device *left_ht, *right_ht; 0 0 0 0 0 0 0 0 0 0 0 0 78 79 bool is_valve_index; 80 }; ··· 145 146 svrb->head = xsysd->static_roles.head; 147 148 - svrb->left_ht = u_system_devices_get_ht_device_left(xsysd); 149 - xsysd->static_roles.hand_tracking.left = svrb->left_ht; 150 - 151 - svrb->right_ht = u_system_devices_get_ht_device_right(xsysd); 152 - xsysd->static_roles.hand_tracking.right = svrb->right_ht; 0 0 0 153 154 /* 155 * Space overseer.

··· 74 struct xrt_builder base; 75 76 struct xrt_device *head; 77 + 78 + struct 79 + { 80 + struct 81 + { 82 + struct xrt_device *left, *right; 83 + } unobstructed; 84 + 85 + struct 86 + { 87 + struct xrt_device *left, *right; 88 + } conforming; 89 + } hand_tracking; 90 91 bool is_valve_index; 92 }; ··· 157 158 svrb->head = xsysd->static_roles.head; 159 160 + #define SET_HT_ROLES(SRC) \ 161 + svrb->hand_tracking.SRC.left = u_system_devices_get_ht_device_##SRC##_left(xsysd); \ 162 + svrb->hand_tracking.SRC.right = u_system_devices_get_ht_device_##SRC##_right(xsysd); \ 163 + xsysd->static_roles.hand_tracking.SRC.left = svrb->hand_tracking.SRC.left; \ 164 + xsysd->static_roles.hand_tracking.SRC.right = svrb->hand_tracking.SRC.right; 165 + SET_HT_ROLES(unobstructed) 166 + SET_HT_ROLES(conforming) 167 + #undef SET_HT_ROLES 168 169 /* 170 * Space overseer.

+2 -2

src/xrt/targets/common/target_builder_wmr.c

··· 300 ubrh->head = head; 301 ubrh->left = left; 302 ubrh->right = right; 303 - ubrh->hand_tracking.left = ht_left; 304 - ubrh->hand_tracking.right = ht_right; 305 306 return XRT_SUCCESS; 307

··· 300 ubrh->head = head; 301 ubrh->left = left; 302 ubrh->right = right; 303 + ubrh->hand_tracking.unobstructed.left = ht_left; 304 + ubrh->hand_tracking.unobstructed.right = ht_right; 305 306 return XRT_SUCCESS; 307

+17 -6

src/xrt/targets/libmonado/monado.c

··· 56 ROLE_LEFT, 57 ROLE_RIGHT, 58 ROLE_GAMEPAD, 59 - ROLE_HAND_LEFT, 60 - ROLE_HAND_RIGHT, 0 0 61 }; 62 63 #define CHECK_NOT_NULL(ARG) \ ··· 430 TO_ENUM("left", ROLE_LEFT) 431 TO_ENUM("right", ROLE_RIGHT) 432 TO_ENUM("gamepad", ROLE_GAMEPAD) 433 - TO_ENUM("hand-tracking-left", ROLE_HAND_LEFT) 434 - TO_ENUM("hand-tracking-right", ROLE_HAND_RIGHT) 0 0 435 { 436 PE("Invalid role name (%s)", role_name); 437 return MND_ERROR_INVALID_VALUE; ··· 441 switch (role) { 442 case ROLE_HEAD: *out_index = root->ipc_c.ism->roles.head; return MND_SUCCESS; 443 case ROLE_EYES: *out_index = root->ipc_c.ism->roles.eyes; return MND_SUCCESS; 444 - case ROLE_HAND_LEFT: *out_index = root->ipc_c.ism->roles.hand_tracking.left; return MND_SUCCESS; 445 - case ROLE_HAND_RIGHT: *out_index = root->ipc_c.ism->roles.hand_tracking.right; return MND_SUCCESS; 0 0 0 0 0 0 0 446 case ROLE_LEFT: 447 case ROLE_RIGHT: 448 case ROLE_GAMEPAD: break;

··· 56 ROLE_LEFT, 57 ROLE_RIGHT, 58 ROLE_GAMEPAD, 59 + ROLE_HAND_UNOBSTRUCTED_LEFT, 60 + ROLE_HAND_UNOBSTRUCTED_RIGHT, 61 + ROLE_HAND_CONFORMING_LEFT, 62 + ROLE_HAND_CONFORMING_RIGHT, 63 }; 64 65 #define CHECK_NOT_NULL(ARG) \ ··· 432 TO_ENUM("left", ROLE_LEFT) 433 TO_ENUM("right", ROLE_RIGHT) 434 TO_ENUM("gamepad", ROLE_GAMEPAD) 435 + TO_ENUM("hand-tracking-unobstructed-left", ROLE_HAND_UNOBSTRUCTED_LEFT) 436 + TO_ENUM("hand-tracking-unobstructed-right", ROLE_HAND_UNOBSTRUCTED_RIGHT) 437 + TO_ENUM("hand-tracking-conforming-left", ROLE_HAND_CONFORMING_LEFT) 438 + TO_ENUM("hand-tracking-conforming-right", ROLE_HAND_CONFORMING_RIGHT) 439 { 440 PE("Invalid role name (%s)", role_name); 441 return MND_ERROR_INVALID_VALUE; ··· 445 switch (role) { 446 case ROLE_HEAD: *out_index = root->ipc_c.ism->roles.head; return MND_SUCCESS; 447 case ROLE_EYES: *out_index = root->ipc_c.ism->roles.eyes; return MND_SUCCESS; 448 + #define CASE_ROLE_HAND(UC_SRC, SRC) \ 449 + case ROLE_HAND_##UC_SRC##_LEFT: *out_index = root->ipc_c.ism->roles.hand_tracking.SRC.left; \ 450 + return MND_SUCCESS; \ 451 + case ROLE_HAND_##UC_SRC##_RIGHT: \ 452 + *out_index = root->ipc_c.ism->roles.hand_tracking.SRC.right; \ 453 + return MND_SUCCESS; 454 + CASE_ROLE_HAND(UNOBSTRUCTED, unobstructed) 455 + CASE_ROLE_HAND(CONFORMING, conforming) 456 + #undef CASE_ROLE_HAND 457 case ROLE_LEFT: 458 case ROLE_RIGHT: 459 case ROLE_GAMEPAD: break;