+2 -2

doc/example_configs/config_v0.schema.json

··· 163 163 "XRT_INPUT_GO_GRIP_POSE", 164 164 "XRT_INPUT_TOUCH_GRIP_POSE", 165 165 "XRT_INPUT_HAND_GRIP_POSE", 166 166 - "XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT", 167 167 - "XRT_INPUT_GENERIC_HAND_TRACKING_LEFT", 166 166 + "XRT_INPUT_HT_UNOBSTRUCTED_RIGHT", 167 167 + "XRT_INPUT_HT_UNOBSTRUCTED_LEFT", 168 168 "XRT_INPUT_GENERIC_TRACKER_POSE", 169 169 "XRT_INPUT_PSMV_GRIP_POSE", 170 170 "XRT_INPUT_GO_AIM_POSE",

+2 -2

src/xrt/auxiliary/bindings/bindings.py

··· 824 824 # special cased bindings that are never directly used in the input profiles 825 825 inputs.add("XRT_INPUT_GENERIC_HEAD_POSE") 826 826 inputs.add("XRT_INPUT_GENERIC_HEAD_DETECT") 827 827 - inputs.add("XRT_INPUT_GENERIC_HAND_TRACKING_LEFT") 828 828 - inputs.add("XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT") 827 827 + inputs.add("XRT_INPUT_HT_UNOBSTRUCTED_LEFT") 828 828 + inputs.add("XRT_INPUT_HT_UNOBSTRUCTED_RIGHT") 829 829 inputs.add("XRT_INPUT_GENERIC_TRACKER_POSE") 830 830 831 831 f.write('const char *\n')

+2 -2

src/xrt/auxiliary/util/u_system_helpers.h

··· 193 193 static inline struct xrt_device * 194 194 u_system_devices_get_ht_device_left(struct xrt_system_devices *xsysd) 195 195 { 196 196 - return u_system_devices_get_ht_device(xsysd, XRT_INPUT_GENERIC_HAND_TRACKING_LEFT); 196 196 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_LEFT); 197 197 } 198 198 199 199 /*! ··· 205 205 static inline struct xrt_device * 206 206 u_system_devices_get_ht_device_right(struct xrt_system_devices *xsysd) 207 207 { 208 208 - return u_system_devices_get_ht_device(xsysd, XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); 208 208 + return u_system_devices_get_ht_device(xsysd, XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); 209 209 } 210 210 211 211

+2 -2

src/xrt/auxiliary/vive/vive_poses.c

··· 138 138 struct xrt_pose *out_offset_pose) 139 139 { 140 140 switch (input_name) { 141 141 - case XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT: 141 141 + case XRT_INPUT_HT_UNOBSTRUCTED_RIGHT: 142 142 vive_poses_get_index_hand_offset_pose(XRT_HAND_RIGHT, out_offset_pose); 143 143 return; 144 144 - case XRT_INPUT_GENERIC_HAND_TRACKING_LEFT: 144 144 + case XRT_INPUT_HT_UNOBSTRUCTED_LEFT: 145 145 vive_poses_get_index_hand_offset_pose(XRT_HAND_LEFT, out_offset_pose); 146 146 return; 147 147 default: break; // Go to code below.

+3 -3

src/xrt/drivers/ht/ht_driver.c

··· 154 154 { 155 155 struct ht_device *htd = ht_device(xdev); 156 156 157 157 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 157 157 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 158 158 U_LOG_XDEV_UNSUPPORTED_INPUT(&htd->base, htd->log_level, name); 159 159 return XRT_ERROR_INPUT_UNSUPPORTED; 160 160 } ··· 212 212 snprintf(htd->base.str, XRT_DEVICE_NAME_LEN, "Camera based Hand Tracker"); 213 213 snprintf(htd->base.serial, XRT_DEVICE_NAME_LEN, "Camera based Hand Tracker"); 214 214 215 215 - htd->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 216 216 - htd->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 215 215 + htd->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 216 216 + htd->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 217 217 218 218 // Yes, you need all of these. Yes, I tried disabling them all one at a time. You need all of these. 219 219 htd->base.name = XRT_DEVICE_HAND_TRACKER;

+2 -3

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

··· 443 443 444 444 445 445 cemud[i]->base.inputs[CEMU_INDEX_HAND_TRACKING].name = 446 446 - i ? XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT : XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 446 446 + i ? XRT_INPUT_HT_UNOBSTRUCTED_RIGHT : XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 447 447 cemud[i]->base.inputs[CEMU_INDEX_SELECT].name = XRT_INPUT_SIMPLE_SELECT_CLICK; 448 448 cemud[i]->base.inputs[CEMU_INDEX_MENU].name = XRT_INPUT_SIMPLE_MENU_CLICK; 449 449 cemud[i]->base.inputs[CEMU_INDEX_GRIP].name = XRT_INPUT_SIMPLE_GRIP_POSE; ··· 469 469 CEMU_WARN(cemud[i], "serial truncated: %s", cemud[i]->base.str); 470 470 } 471 471 472 472 - cemud[i]->ht_input_name = 473 473 - i ? XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT : XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 472 472 + cemud[i]->ht_input_name = i ? XRT_INPUT_HT_UNOBSTRUCTED_RIGHT : XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 474 473 475 474 cemud[i]->hand_index = i; 476 475 system->out_hand[i] = cemud[i];

+1 -1

src/xrt/drivers/opengloves/opengloves_device.c

··· 297 297 // hand tracking 298 298 od->base.get_hand_tracking = opengloves_device_get_hand_tracking; 299 299 od->base.inputs[OPENGLOVES_INPUT_INDEX_HAND_TRACKING].name = 300 300 - od->hand == XRT_HAND_LEFT ? XRT_INPUT_GENERIC_HAND_TRACKING_LEFT : XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 300 300 + od->hand == XRT_HAND_LEFT ? XRT_INPUT_HT_UNOBSTRUCTED_LEFT : XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 301 301 302 302 od->base.supported.hand_tracking = true; 303 303 od->base.supported.force_feedback = true;

+3 -3

src/xrt/drivers/remote/r_device.c

··· 147 147 struct r_device *rd = r_device(xdev); 148 148 struct r_hub *r = rd->r; 149 149 150 150 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 150 150 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 151 151 U_LOG_XDEV_UNSUPPORTED_INPUT(&rd->base, u_log_get_global_level(), name); 152 152 return XRT_ERROR_INPUT_UNSUPPORTED; 153 153 } ··· 236 236 rd->base.inputs[17].name = XRT_INPUT_INDEX_GRIP_POSE; 237 237 rd->base.inputs[18].name = XRT_INPUT_INDEX_AIM_POSE; 238 238 if (is_left) { 239 239 - rd->base.inputs[19].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 239 239 + rd->base.inputs[19].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 240 240 } else { 241 241 - rd->base.inputs[19].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 241 241 + rd->base.inputs[19].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 242 242 } 243 243 rd->base.inputs[20].name = XRT_INPUT_GENERIC_PALM_POSE; 244 244

+3 -3

src/xrt/drivers/steamvr_lh/device.cpp

··· 261 261 finger_inputs_map.insert({path, &finger_inputs_vec.back()}); 262 262 } 263 263 assert(inputs_vec.capacity() >= inputs_vec.size() + 1); 264 264 - inputs_vec.push_back({true, 0, XRT_INPUT_GENERIC_HAND_TRACKING_LEFT, {}}); 264 264 + inputs_vec.push_back({true, 0, XRT_INPUT_HT_UNOBSTRUCTED_LEFT, {}}); 265 265 inputs_map.insert({std::string_view("HAND"), &inputs_vec.back()}); 266 266 } 267 267 ··· 875 875 } 876 876 case vr::TrackedControllerRole_RightHand: { 877 877 this->device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER; 878 878 - set_hand_tracking_hand(XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); 878 878 + set_hand_tracking_hand(XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); 879 879 break; 880 880 } 881 881 case vr::TrackedControllerRole_LeftHand: { 882 882 this->device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER; 883 883 - set_hand_tracking_hand(XRT_INPUT_GENERIC_HAND_TRACKING_LEFT); 883 883 + set_hand_tracking_hand(XRT_INPUT_HT_UNOBSTRUCTED_LEFT); 884 884 break; 885 885 } 886 886 case vr::TrackedControllerRole_OptOut: {

+3 -4

src/xrt/drivers/survive/survive_driver.c

··· 468 468 { 469 469 struct survive_device *survive = (struct survive_device *)xdev; 470 470 471 471 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 471 471 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 472 472 U_LOG_XDEV_UNSUPPORTED_INPUT(&survive->base, survive->sys->log_level, name); 473 473 return XRT_ERROR_INPUT_UNSUPPORTED; 474 474 } ··· 1136 1136 1137 1137 if (variant == CONTROLLER_INDEX_LEFT) { 1138 1138 survive->base.device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER; 1139 1139 - survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 1139 1139 + survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 1140 1140 snprintf(survive->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Left Controller (libsurvive)"); 1141 1141 } else if (variant == CONTROLLER_INDEX_RIGHT) { 1142 1142 survive->base.device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER; 1143 1143 - survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = 1144 1144 - XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 1143 1143 + survive->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 1145 1144 snprintf(survive->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Right Controller (libsurvive)"); 1146 1145 } 1147 1146

+4 -4

src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp

··· 331 331 { 332 332 struct ulv2_device *ulv2d = ulv2_device(xdev); 333 333 334 334 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 334 334 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 335 335 ULV2_ERROR(ulv2d, "unknown input name for hand tracker"); 336 336 return; 337 337 } 338 338 339 339 - bool hand_index = (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); // 0 if left, 1 if right. 339 339 + bool hand_index = (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); // 0 if left, 1 if right. 340 340 341 341 bool hand_valid = ulv2d->hand_exists[hand_index]; 342 342 ··· 398 398 strncpy(ulv2d->base.str, "Leap Motion v2 driver", XRT_DEVICE_NAME_LEN); 399 399 strncpy(ulv2d->base.serial, "Leap Motion v2 driver", XRT_DEVICE_NAME_LEN); 400 400 401 401 - ulv2d->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 402 402 - ulv2d->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 401 401 + ulv2d->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 402 402 + ulv2d->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 403 403 404 404 ulv2d->base.name = XRT_DEVICE_HAND_TRACKER; 405 405

+4 -4

src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp

··· 96 96 { 97 97 struct ulv5_device *ulv5d = ulv5_device(xdev); 98 98 99 99 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 99 99 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 100 100 U_LOG_XDEV_UNSUPPORTED_INPUT(&ulv5d->base, ulv5d->log_level, name); 101 101 return XRT_ERROR_INPUT_UNSUPPORTED; 102 102 } 103 103 104 104 - bool hand_index = (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); // 0 if left, 1 if right. 104 104 + bool hand_index = (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); // 0 if left, 1 if right. 105 105 106 106 bool hand_valid = ulv5d->hand_exists[hand_index]; 107 107 ··· 317 317 strncpy(ulv5d->base.str, "Leap Motion v5 driver", XRT_DEVICE_NAME_LEN); 318 318 strncpy(ulv5d->base.serial, "Leap Motion v5 driver", XRT_DEVICE_NAME_LEN); 319 319 320 320 - ulv5d->base.inputs[0].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 321 321 - ulv5d->base.inputs[1].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 320 320 + ulv5d->base.inputs[0].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 321 321 + ulv5d->base.inputs[1].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 322 322 323 323 ulv5d->base.name = XRT_DEVICE_HAND_TRACKER; 324 324

+3 -3

src/xrt/drivers/vive/vive_controller.c

··· 375 375 376 376 struct vive_controller_device *d = vive_controller_device(xdev); 377 377 378 378 - if (name != XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && name != XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 378 378 + if (name != XRT_INPUT_HT_UNOBSTRUCTED_LEFT && name != XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 379 379 U_LOG_XDEV_UNSUPPORTED_INPUT(&d->base, d->log_level, name); 380 380 return XRT_ERROR_INPUT_UNSUPPORTED; 381 381 } ··· 1181 1181 1182 1182 if (d->config.variant == CONTROLLER_INDEX_LEFT) { 1183 1183 d->base.device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER; 1184 1184 - d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_LEFT; 1184 1184 + d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_LEFT; 1185 1185 snprintf(d->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Left Controller (vive)"); 1186 1186 } else if (d->config.variant == CONTROLLER_INDEX_RIGHT) { 1187 1187 d->base.device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER; 1188 1188 - d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT; 1188 1188 + d->base.inputs[VIVE_CONTROLLER_HAND_TRACKING].name = XRT_INPUT_HT_UNOBSTRUCTED_RIGHT; 1189 1189 snprintf(d->base.str, XRT_DEVICE_NAME_LEN, "Valve Index Right Controller (vive)"); 1190 1190 } 1191 1191 } else if (d->config.variant == CONTROLLER_TRACKER_GEN1) {

+2 -2

src/xrt/include/xrt/xrt_defines.h

··· 880 880 /** Standard pose used for rendering */ \ 881 881 _(XRT_INPUT_GENERIC_HEAD_POSE , XRT_INPUT_NAME(0x0000, POSE)) \ 882 882 _(XRT_INPUT_GENERIC_HEAD_DETECT , XRT_INPUT_NAME(0x0001, BOOLEAN)) \ 883 883 - _(XRT_INPUT_GENERIC_HAND_TRACKING_LEFT , XRT_INPUT_NAME(0x0002, HAND_TRACKING)) \ 884 884 - _(XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT , XRT_INPUT_NAME(0x0004, HAND_TRACKING)) \ 883 883 + _(XRT_INPUT_HT_UNOBSTRUCTED_LEFT , XRT_INPUT_NAME(0x0002, HAND_TRACKING)) \ 884 884 + _(XRT_INPUT_HT_UNOBSTRUCTED_RIGHT , XRT_INPUT_NAME(0x0004, HAND_TRACKING)) \ 885 885 _(XRT_INPUT_GENERIC_TRACKER_POSE , XRT_INPUT_NAME(0x0005, POSE)) \ 886 886 /** XR_EXT_palm_pose */ \ 887 887 _(XRT_INPUT_GENERIC_PALM_POSE , XRT_INPUT_NAME(0x0006, POSE)) \

+2 -4

src/xrt/state_trackers/oxr/oxr_api_session.c

··· 444 444 for (uint32_t j = 0; j < xdev->input_count; j++) { 445 445 struct xrt_input *input = &xdev->inputs[j]; 446 446 447 447 - if ((input->name == XRT_INPUT_GENERIC_HAND_TRACKING_LEFT && 448 448 - createInfo->hand == XR_HAND_LEFT_EXT) || 449 449 - (input->name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT && 450 450 - createInfo->hand == XR_HAND_RIGHT_EXT)) { 447 447 + if ((input->name == XRT_INPUT_HT_UNOBSTRUCTED_LEFT && createInfo->hand == XR_HAND_LEFT_EXT) || 448 448 + (input->name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT && createInfo->hand == XR_HAND_RIGHT_EXT)) { 451 449 hand_tracker->xdev = xdev; 452 450 hand_tracker->input_name = input->name; 453 451 break;

+4 -5

src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp

··· 573 573 574 574 AddSkeletonControl(("/input/skeleton/" + str_hand).c_str(), 575 575 ("/skeleton/hand/" + str_hand).c_str(), 576 576 - XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); 576 576 + XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); 577 577 RunFrame(); 578 578 } else 579 579 ovrd_log("Not enabling skeletal input as this device does not support it"); ··· 973 973 int64_t out_timestamp_ns; 974 974 975 975 m_xdev->get_hand_tracking(m_xdev, 976 976 - m_hand == XRT_HAND_LEFT ? XRT_INPUT_GENERIC_HAND_TRACKING_LEFT 977 977 - : XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT, 976 976 + m_hand == XRT_HAND_LEFT ? XRT_INPUT_HT_UNOBSTRUCTED_LEFT 977 977 + : XRT_INPUT_HT_UNOBSTRUCTED_RIGHT, 978 978 now_ns, &out_joint_set_value, &out_timestamp_ns); 979 979 980 980 hand_joint_set_to_bone_transform(out_joint_set_value, bone_transforms, m_hand); ··· 1091 1091 ovrd_log("Display Frequency: %f\n", m_flDisplayFrequency); 1092 1092 ovrd_log("IPD: %f\n", m_flIPD); 1093 1093 }; 1094 1094 - virtual ~CDeviceDriver_Monado(){}; 1095 1095 - 1096 1094 // clang-format off 1095 1095 + virtual ~CDeviceDriver_Monado() {}; 1097 1096 1098 1097 // ITrackedDeviceServerDriver 1099 1098 virtual vr::EVRInitError Activate(vr::TrackedDeviceIndex_t unObjectId);

+2 -2

src/xrt/tracking/hand/t_hand_tracking_async.c

··· 264 264 int64_t *out_timestamp_ns) 265 265 { 266 266 struct ht_async_impl *hta = ht_async_impl(ht_async); 267 267 - assert(name == XRT_INPUT_GENERIC_HAND_TRACKING_LEFT || name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT); 267 267 + assert(name == XRT_INPUT_HT_UNOBSTRUCTED_LEFT || name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT); 268 268 269 269 int idx = 0; 270 270 - if (name == XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT) { 270 270 + if (name == XRT_INPUT_HT_UNOBSTRUCTED_RIGHT) { 271 271 idx = 1; 272 272 } 273 273