+2 -1

src/xrt/drivers/android/android_sensors.c

··· 170 170 free(android); 171 171 } 172 172 173 173 - static void 173 173 + static xrt_result_t 174 174 android_device_get_tracked_pose(struct xrt_device *xdev, 175 175 enum xrt_input_name name, 176 176 int64_t at_timestamp_ns, ··· 189 189 XRT_SPACE_RELATION_POSITION_VALID_BIT); 190 190 191 191 *out_relation = new_relation; 192 192 + return XRT_SUCCESS; 192 193 } 193 194 194 195

+5 -3

src/xrt/drivers/arduino/arduino_device.c

··· 273 273 * 274 274 */ 275 275 276 276 - static void 276 276 + static xrt_result_t 277 277 arduino_get_fusion_pose(struct arduino_device *ad, enum xrt_input_name name, struct xrt_space_relation *out_relation) 278 278 { 279 279 out_relation->pose.orientation = ad->fusion.rot; ··· 281 281 //! @todo assuming that orientation is actually currently tracked. 282 282 out_relation->relation_flags = (enum xrt_space_relation_flags)(XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | 283 283 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT); 284 284 + 285 285 + return XRT_SUCCESS; 284 286 } 285 287 286 288 static void ··· 331 333 return XRT_SUCCESS; 332 334 } 333 335 334 334 - static void 336 336 + static xrt_result_t 335 337 arduino_device_get_tracked_pose(struct xrt_device *xdev, 336 338 enum xrt_input_name name, 337 339 int64_t at_timestamp_ns, ··· 340 342 struct arduino_device *ad = arduino_device(xdev); 341 343 342 344 (void)at_timestamp_ns; 343 343 - arduino_get_fusion_pose(ad, name, out_relation); 345 345 + return arduino_get_fusion_pose(ad, name, out_relation); 344 346 } 345 347 346 348

+3 -1

src/xrt/drivers/daydream/daydream_device.c

··· 310 310 return XRT_SUCCESS; 311 311 } 312 312 313 313 - static void 313 313 + static xrt_result_t 314 314 daydream_device_get_tracked_pose(struct xrt_device *xdev, 315 315 enum xrt_input_name name, 316 316 int64_t at_timestamp_ns, ··· 320 320 321 321 (void)at_timestamp_ns; 322 322 daydream_get_fusion_pose(daydream, name, out_relation); 323 323 + 324 324 + return XRT_SUCCESS; 323 325 } 324 326 325 327

+3 -1

src/xrt/drivers/euroc/euroc_device.c

··· 102 102 return (struct euroc_device *)xdev; 103 103 } 104 104 105 105 - static void 105 105 + static xrt_result_t 106 106 euroc_device_get_tracked_pose(struct xrt_device *xdev, 107 107 enum xrt_input_name name, 108 108 int64_t at_timestamp_ns, ··· 128 128 out_relation->relation_flags = (enum xrt_space_relation_flags)( 129 129 XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_POSITION_VALID_BIT | 130 130 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT); 131 131 + 132 132 + return XRT_SUCCESS; 131 133 } 132 134 133 135 static void

+5 -4

src/xrt/drivers/hdk/hdk_device.cpp

··· 213 213 return 1; 214 214 } 215 215 216 216 - static void 216 216 + static xrt_result_t 217 217 hdk_device_get_tracked_pose(struct xrt_device *xdev, 218 218 enum xrt_input_name name, 219 219 int64_t requested_timestamp_ns, ··· 222 222 struct hdk_device *hd = hdk_device(xdev); 223 223 224 224 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 225 225 - HDK_ERROR(hd, "unknown input name"); 226 226 - return; 225 225 + U_LOG_XDEV_UNSUPPORTED_INPUT(&hd->base, hd->log_level, name); 226 226 + return XRT_ERROR_INPUT_UNSUPPORTED; 227 227 } 228 228 229 229 os_mutex_lock(&hd->lock); ··· 231 231 out_relation->relation_flags = XRT_SPACE_RELATION_BITMASK_NONE; 232 232 HDK_TRACE(hd, "GET_TRACKED_POSE: No pose"); 233 233 os_mutex_unlock(&hd->lock); 234 234 - return; 234 234 + return XRT_SUCCESS; 235 235 } 236 236 237 237 out_relation->pose.orientation = hd->quat; ··· 248 248 249 249 HDK_TRACE(hd, "GET_TRACKED_POSE (%f, %f, %f, %f) ANG_VEL (%f, %f, %f)", hd->quat.x, hd->quat.y, hd->quat.z, 250 250 hd->quat.w, hd->ang_vel_quat.x, hd->ang_vel_quat.y, hd->ang_vel_quat.z); 251 251 + return XRT_SUCCESS; 251 252 } 252 253 253 254 static void *

+29 -15

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

··· 175 175 return out_relation.pose; 176 176 } 177 177 178 178 - static void 178 178 + static xrt_result_t 179 179 do_grip_pose(struct xrt_hand_joint_set *joint_set, 180 180 struct xrt_space_relation *out_relation, 181 181 float grip_offset_from_palm, ··· 211 211 math_quat_from_plus_x_z(&plus_x, &plus_z, &out_relation->pose.orientation); 212 212 213 213 out_relation->relation_flags = valid_flags; 214 214 + 215 215 + return XRT_SUCCESS; 214 216 } 215 217 216 218 217 219 218 218 - static void 220 220 + static xrt_result_t 219 221 get_other_two(struct cemu_device *dev, 220 222 int64_t head_timestamp_ns, 221 223 int64_t hand_timestamp_ns, ··· 223 225 xrt_hand_joint_set *out_secondary) 224 226 { 225 227 struct xrt_space_relation head_rel; 226 226 - xrt_device_get_tracked_pose(dev->sys->in_head, XRT_INPUT_GENERIC_HEAD_POSE, head_timestamp_ns, &head_rel); 228 228 + xrt_result_t xret = 229 229 + xrt_device_get_tracked_pose(dev->sys->in_head, XRT_INPUT_GENERIC_HEAD_POSE, head_timestamp_ns, &head_rel); 230 230 + if (xret != XRT_SUCCESS) { 231 231 + return xret; 232 232 + } 233 233 + 227 234 *out_head = head_rel.pose; 228 235 int other; 229 236 if (dev->hand_index == 0) { ··· 235 242 int64_t noop; 236 243 xrt_device_get_hand_tracking(dev->sys->in_hand, dev->sys->out_hand[other]->ht_input_name, hand_timestamp_ns, 237 244 out_secondary, &noop); 245 245 + 246 246 + return xret; 238 247 } 239 248 240 249 // Mostly stolen from 241 250 // https://github.com/maluoi/StereoKit/blob/048b689f71d080a67fde29838c0362a49b88b3d6/StereoKitC/systems/hand/hand_oxr_articulated.cpp#L149 242 242 - static void 251 251 + static xrt_result_t 243 252 do_aim_pose(struct cemu_device *dev, 244 253 struct xrt_hand_joint_set *joint_set_primary, 245 254 int64_t head_timestamp_ns, ··· 251 260 struct xrt_hand_joint_set joint_set_secondary; 252 261 #if 0 253 262 // "Jakob way" 254 254 - get_other_two(dev, hand_timestamp_ns, hand_timestamp_ns, &head, &joint_set_secondary); 263 263 + xrt_result_t xret = get_other_two(dev, hand_timestamp_ns, hand_timestamp_ns, &head, &joint_set_secondary); 255 264 #else 256 265 // "Moses way" 257 257 - get_other_two(dev, head_timestamp_ns, hand_timestamp_ns, &head, &joint_set_secondary); 266 266 + xrt_result_t xret = get_other_two(dev, head_timestamp_ns, hand_timestamp_ns, &head, &joint_set_secondary); 258 267 #endif 259 259 - 268 268 + if (xret != XRT_SUCCESS) { 269 269 + return xret; 270 270 + } 260 271 261 272 // Average shoulder width for women:37cm, men:41cm, center of shoulder 262 273 // joint is around 4cm inwards ··· 313 324 math_quat_from_plus_x_z(&out_x_vector, &ray_direction, &out_relation->pose.orientation); 314 325 315 326 out_relation->relation_flags = valid_flags; 327 327 + 328 328 + return xret; 316 329 } 317 330 318 331 // Pose for controller emulation 319 319 - static void 332 332 + static xrt_result_t 320 333 cemu_device_get_tracked_pose(struct xrt_device *xdev, 321 334 enum xrt_input_name name, 322 335 int64_t at_timestamp_ns, ··· 326 339 struct cemu_system *sys = dev->sys; 327 340 328 341 if (name != XRT_INPUT_SIMPLE_GRIP_POSE && name != XRT_INPUT_SIMPLE_AIM_POSE) { 329 329 - CEMU_ERROR(dev, "unknown input name %d for controller pose", name); 330 330 - return; 342 342 + U_LOG_XDEV_UNSUPPORTED_INPUT(&dev->base, dev->sys->log_level, name); 343 343 + return XRT_ERROR_INPUT_UNSUPPORTED; 331 344 } 332 345 static int64_t hand_timestamp_ns; 333 346 ··· 337 350 338 351 if (joint_set.is_active == false) { 339 352 out_relation->relation_flags = XRT_SPACE_RELATION_BITMASK_NONE; 340 340 - return; 353 353 + return XRT_SUCCESS; 341 354 } 342 355 343 343 - 344 344 - 356 356 + xrt_result_t xret = XRT_SUCCESS; 345 357 switch (name) { 346 358 case XRT_INPUT_SIMPLE_GRIP_POSE: { 347 347 - do_grip_pose(&joint_set, out_relation, sys->grip_offset_from_palm, dev->hand_index); 359 359 + xret = do_grip_pose(&joint_set, out_relation, sys->grip_offset_from_palm, dev->hand_index); 348 360 break; 349 361 } 350 362 case XRT_INPUT_SIMPLE_AIM_POSE: { 351 363 // Assume that now we're doing everything in the timestamp from the hand-tracker, so use 352 364 // hand_timestamp_ns. This will cause the controller to lag behind but otherwise be correct 353 353 - do_aim_pose(dev, &joint_set, at_timestamp_ns, hand_timestamp_ns, out_relation); 365 365 + xret = do_aim_pose(dev, &joint_set, at_timestamp_ns, hand_timestamp_ns, out_relation); 354 366 break; 355 367 } 356 368 default: assert(false); 357 369 } 370 370 + 371 371 + return xret; 358 372 } 359 373 360 374 static void

+3 -1

src/xrt/drivers/hydra/hydra_driver.c

··· 482 482 return XRT_SUCCESS; 483 483 } 484 484 485 485 - static void 485 485 + static xrt_result_t 486 486 hydra_device_get_tracked_pose(struct xrt_device *xdev, 487 487 enum xrt_input_name name, 488 488 int64_t at_timestamp_ns, ··· 505 505 // HYDRA_SPEW(hd, "GET_TRACKED_POSE (%f, %f, %f) (%f, %f, %f, %f) ", 506 506 // pos.x, 507 507 // pos.y, pos.z, quat.x, quat.y, quat.z, quat.w); 508 508 + 509 509 + return XRT_SUCCESS; 508 510 } 509 511 510 512 static void

+12 -4

src/xrt/drivers/multi_wrapper/multi.c

··· 79 79 m_relation_chain_resolve(&xrc, out_relation); 80 80 } 81 81 82 82 - static void 82 82 + static xrt_result_t 83 83 get_tracked_pose(struct xrt_device *xdev, 84 84 enum xrt_input_name name, 85 85 int64_t at_timestamp_ns, ··· 91 91 92 92 struct xrt_space_relation tracker_relation; 93 93 94 94 - xrt_device_get_tracked_pose(tracker, tracker_input_name, at_timestamp_ns, &tracker_relation); 94 94 + xrt_result_t xret = 95 95 + xrt_device_get_tracked_pose(tracker, tracker_input_name, at_timestamp_ns, &tracker_relation); 96 96 + if (xret != XRT_SUCCESS) { 97 97 + return xret; 98 98 + } 95 99 96 100 switch (d->override_type) { 97 101 case XRT_TRACKING_OVERRIDE_DIRECT: { ··· 101 105 struct xrt_device *target = d->tracking_override.target; 102 106 103 107 struct xrt_space_relation target_relation; 104 104 - xrt_device_get_tracked_pose(target, name, at_timestamp_ns, &target_relation); 105 105 - 108 108 + xret = xrt_device_get_tracked_pose(target, name, at_timestamp_ns, &target_relation); 109 109 + if (xret != XRT_SUCCESS) { 110 110 + break; 111 111 + } 106 112 107 113 // just use the origin of the tracker space as reference frame 108 114 struct xrt_space_relation in_target_space; ··· 116 122 &in_target_space, out_relation); 117 123 } break; 118 124 } 125 125 + 126 126 + return xret; 119 127 } 120 128 121 129 static void

+4 -3

src/xrt/drivers/north_star/ns_hmd.c

··· 367 367 u_device_free(&ns->base); 368 368 } 369 369 370 370 - static void 370 370 + static xrt_result_t 371 371 ns_hmd_get_tracked_pose(struct xrt_device *xdev, 372 372 enum xrt_input_name name, 373 373 int64_t at_timestamp_ns, ··· 377 377 NS_DEBUG(ns, "Called!"); 378 378 379 379 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 380 380 - NS_ERROR(ns, "unknown input name"); 381 381 - return; 380 380 + U_LOG_XDEV_UNSUPPORTED_INPUT(&ns->base, ns->log_level, name); 381 381 + return XRT_ERROR_INPUT_UNSUPPORTED; 382 382 } 383 383 384 384 *out_relation = ns->no_tracker_relation; // you can change this using the debug gui 385 385 + return XRT_SUCCESS; 385 386 } 386 387 387 388 static void

+6 -4

src/xrt/drivers/ohmd/oh_device.c

··· 373 373 return (ohd->ohmd_device_type == OPENHMD_GENERIC_TRACKER) && name == XRT_INPUT_GENERIC_TRACKER_POSE; 374 374 } 375 375 376 376 - static void 376 376 + static xrt_result_t 377 377 oh_device_get_tracked_pose(struct xrt_device *xdev, 378 378 enum xrt_input_name name, 379 379 int64_t at_timestamp_ns, ··· 384 384 struct xrt_vec3 pos = XRT_VEC3_ZERO; 385 385 386 386 if (!check_head_pose(ohd, name) && !check_controller_pose(ohd, name) && !check_tracker_pose(ohd, name)) { 387 387 - OHMD_ERROR(ohd, "unknown input name: %d", name); 388 388 - return; 387 387 + U_LOG_XDEV_UNSUPPORTED_INPUT(&ohd->base, ohd->log_level, name); 388 388 + return XRT_ERROR_INPUT_UNSUPPORTED; 389 389 } 390 390 391 391 ohmd_ctx_update(ohd->ctx); ··· 429 429 */ 430 430 *out_relation = ohd->last_relation; 431 431 OHMD_TRACE(ohd, "GET_TRACKED_POSE (%s) - no new data", ohd->base.str); 432 432 - return; 432 432 + return XRT_SUCCESS; 433 433 } 434 434 435 435 /*! ··· 470 470 // Update state within driver 471 471 ohd->last_update = (int64_t)now; 472 472 ohd->last_relation = *out_relation; 473 473 + 474 474 + return XRT_SUCCESS; 473 475 } 474 476 475 477

+31 -45

src/xrt/drivers/psmv/psmv_driver.c

··· 794 794 XRT_SPACE_RELATION_ANGULAR_VELOCITY_VALID_BIT | XRT_SPACE_RELATION_LINEAR_VELOCITY_VALID_BIT); 795 795 } 796 796 797 797 - static void 798 798 - psmv_push_pose_offset(enum xrt_input_name name, struct xrt_relation_chain *xrc) 799 799 - { 800 800 - /* 801 801 - * Both the grip and aim pose needs adjustments, the grip is a rotated 802 802 - * body center pose, while the aim pose needs to rotated and translated 803 803 - * to the tip of the ball. 804 804 - */ 805 805 - if (name != XRT_INPUT_PSMV_AIM_POSE && name != XRT_INPUT_PSMV_GRIP_POSE) { 806 806 - return; 807 807 - } 808 808 - 809 809 - float y = 0.0; 810 810 - if (name == XRT_INPUT_PSMV_AIM_POSE) { 811 811 - y += PSMV_BALL_FROM_IMU_Y_M; 812 812 - y += PSMV_BALL_DIAMETER_M / 2.0; 813 813 - } 814 814 - 815 815 - struct xrt_pose pose = { 816 816 - {0.7071068, 0, 0, 0.7071068}, 817 817 - {0, y, 0}, 818 818 - }; 819 819 - 820 820 - m_relation_chain_push_pose(xrc, &pose); 821 821 - } 822 822 - 823 797 824 798 /* 825 799 * ··· 888 862 } 889 863 890 864 static xrt_result_t 891 891 - psmv_device_get_relation_chain(struct xrt_device *xdev, 892 892 - enum xrt_input_name name, 893 893 - uint64_t at_timestamp_ns, 894 894 - struct xrt_relation_chain *xrc) 865 865 + psmv_device_get_tracked_pose(struct xrt_device *xdev, 866 866 + enum xrt_input_name name, 867 867 + int64_t at_timestamp_ns, 868 868 + struct xrt_space_relation *out_relation) 895 869 { 896 870 struct psmv_device *psmv = psmv_device(xdev); 897 871 898 898 - psmv_push_pose_offset(name, xrc); 872 872 + if (name != XRT_INPUT_PSMV_AIM_POSE && name != XRT_INPUT_PSMV_GRIP_POSE) { 873 873 + U_LOG_XDEV_UNSUPPORTED_INPUT(&psmv->base, psmv->log_level, name); 874 874 + return XRT_ERROR_INPUT_UNSUPPORTED; 875 875 + } 899 876 900 900 - struct xrt_space_relation *rel = m_relation_chain_reserve(xrc); 877 877 + /* 878 878 + * Both the grip and aim pose needs adjustments, the grip is a rotated 879 879 + * body center pose, while the aim pose needs to rotated and translated 880 880 + * to the tip of the ball. 881 881 + */ 901 882 902 902 - if (psmv->ball != NULL) { 903 903 - xrt_tracked_psmv_get_tracked_pose(psmv->ball, name, at_timestamp_ns, rel); 904 904 - } else { 905 905 - psmv_get_fusion_pose(psmv, name, at_timestamp_ns, rel); 883 883 + float y = 0.0; 884 884 + if (name == XRT_INPUT_PSMV_AIM_POSE) { 885 885 + y += PSMV_BALL_FROM_IMU_Y_M; 886 886 + y += PSMV_BALL_DIAMETER_M / 2.0; 906 887 } 907 888 908 908 - return XRT_SUCCESS; 909 909 - } 889 889 + struct xrt_pose pose = { 890 890 + {0.7071068, 0, 0, 0.7071068}, 891 891 + {0, y, 0}, 892 892 + }; 910 893 911 911 - static void 912 912 - psmv_device_get_tracked_pose(struct xrt_device *xdev, 913 913 - enum xrt_input_name name, 914 914 - int64_t at_timestamp_ns, 915 915 - struct xrt_space_relation *out_relation) 916 916 - { 917 894 struct xrt_relation_chain xrc = {0}; 895 895 + m_relation_chain_push_pose(&xrc, &pose); 918 896 919 919 - psmv_device_get_relation_chain(xdev, name, at_timestamp_ns, &xrc); 897 897 + struct xrt_space_relation *rel = m_relation_chain_reserve(&xrc); 898 898 + 899 899 + if (psmv->ball != NULL) { 900 900 + xrt_tracked_psmv_get_tracked_pose(psmv->ball, name, at_timestamp_ns, rel); 901 901 + } else { 902 902 + psmv_get_fusion_pose(psmv, name, at_timestamp_ns, rel); 903 903 + } 920 904 921 905 m_relation_chain_resolve(&xrc, out_relation); 906 906 + 907 907 + return XRT_SUCCESS; 922 908 } 923 909 924 910 static float

+5 -3

src/xrt/drivers/pssense/pssense_driver.c

··· 757 757 XRT_SPACE_RELATION_ANGULAR_VELOCITY_VALID_BIT | XRT_SPACE_RELATION_LINEAR_VELOCITY_VALID_BIT); 758 758 } 759 759 760 760 - static void 760 760 + static xrt_result_t 761 761 pssense_get_tracked_pose(struct xrt_device *xdev, 762 762 enum xrt_input_name name, 763 763 int64_t at_timestamp_ns, ··· 766 766 struct pssense_device *pssense = (struct pssense_device *)xdev; 767 767 768 768 if (name != XRT_INPUT_PSSENSE_AIM_POSE && name != XRT_INPUT_PSSENSE_GRIP_POSE) { 769 769 - PSSENSE_ERROR(pssense, "Unknown pose name requested %u", name); 770 770 - return; 769 769 + U_LOG_XDEV_UNSUPPORTED_INPUT(&pssense->base, pssense->log_level, name); 770 770 + return XRT_ERROR_INPUT_UNSUPPORTED; 771 771 } 772 772 773 773 struct xrt_relation_chain xrc = {0}; ··· 785 785 os_mutex_unlock(&pssense->lock); 786 786 787 787 m_relation_chain_resolve(&xrc, out_relation); 788 788 + 789 789 + return XRT_SUCCESS; 788 790 } 789 791 790 792 static xrt_result_t

+5 -3

src/xrt/drivers/psvr/psvr_device.c

··· 957 957 return XRT_SUCCESS; 958 958 } 959 959 960 960 - static void 960 960 + static xrt_result_t 961 961 psvr_device_get_tracked_pose(struct xrt_device *xdev, 962 962 enum xrt_input_name name, 963 963 int64_t at_timestamp_ns, ··· 966 966 struct psvr_device *psvr = psvr_device(xdev); 967 967 968 968 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 969 969 - PSVR_ERROR(psvr, "unknown input name"); 970 970 - return; 969 969 + U_LOG_XDEV_UNSUPPORTED_INPUT(&psvr->base, psvr->log_level, name); 970 970 + return XRT_ERROR_INPUT_UNSUPPORTED; 971 971 } 972 972 973 973 os_mutex_lock(&psvr->device_mutex); ··· 993 993 //! @todo Move this to the tracker. 994 994 // Make sure that the orientation is valid. 995 995 math_quat_normalize(&out_relation->pose.orientation); 996 996 + 997 997 + return XRT_SUCCESS; 996 998 } 997 999 998 1000 static void

+5 -3

src/xrt/drivers/qwerty/qwerty_device.c

··· 136 136 } 137 137 } 138 138 139 139 - static void 139 139 + static xrt_result_t 140 140 qwerty_get_tracked_pose(struct xrt_device *xd, 141 141 enum xrt_input_name name, 142 142 int64_t at_timestamp_ns, ··· 146 146 147 147 if (name != XRT_INPUT_GENERIC_HEAD_POSE && name != XRT_INPUT_SIMPLE_GRIP_POSE && 148 148 name != XRT_INPUT_SIMPLE_AIM_POSE) { 149 149 - QWERTY_ERROR(qd, "Unexpected input name = 0x%04X", name >> 8); 150 150 - return; 149 149 + U_LOG_XDEV_UNSUPPORTED_INPUT(&qd->base, qd->sys->log_level, name); 150 150 + return XRT_ERROR_INPUT_UNSUPPORTED; 151 151 } 152 152 153 153 // Position ··· 201 201 out_relation->relation_flags = 202 202 XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_POSITION_VALID_BIT | 203 203 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT; 204 204 + 205 205 + return XRT_SUCCESS; 204 206 } 205 207 206 208 static void

+4 -3

src/xrt/drivers/realsense/rs_ddev.c

··· 388 388 * 389 389 */ 390 390 391 391 - static void 391 391 + static xrt_result_t 392 392 rs_ddev_get_tracked_pose(struct xrt_device *xdev, 393 393 enum xrt_input_name name, 394 394 int64_t at_timestamp_ns, ··· 397 397 struct rs_ddev *rs = rs_ddev(xdev); 398 398 399 399 if (name != XRT_INPUT_GENERIC_TRACKER_POSE) { 400 400 - U_LOG_E("unknown input name"); 401 401 - return; 400 400 + U_LOG_XDEV_UNSUPPORTED_INPUT(&rs->base, u_log_get_global_level(), name); 401 401 + return XRT_ERROR_INPUT_UNSUPPORTED; 402 402 } 403 403 404 404 m_relation_history_get(rs->relation_hist, at_timestamp_ns, out_relation); 405 405 + return XRT_SUCCESS; 405 406 } 406 407 407 408 static void

+3 -1

src/xrt/drivers/realsense/rs_hdev.c

··· 273 273 return out_relation.pose; 274 274 } 275 275 276 276 - static void 276 276 + static xrt_result_t 277 277 rs_hdev_get_tracked_pose(struct xrt_device *xdev, 278 278 enum xrt_input_name name, 279 279 int64_t at_timestamp_ns, ··· 305 305 out_relation->relation_flags = (enum xrt_space_relation_flags)( 306 306 XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_POSITION_VALID_BIT | 307 307 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT); 308 308 + 309 309 + return XRT_SUCCESS; 308 310 } 309 311 310 312 static void

+5 -3

src/xrt/drivers/remote/r_device.c

··· 97 97 return XRT_SUCCESS; 98 98 } 99 99 100 100 - static void 100 100 + static xrt_result_t 101 101 r_device_get_tracked_pose(struct xrt_device *xdev, 102 102 enum xrt_input_name name, 103 103 int64_t at_timestamp_ns, ··· 108 108 109 109 if (name != XRT_INPUT_INDEX_AIM_POSE && name != XRT_INPUT_INDEX_GRIP_POSE && 110 110 name != XRT_INPUT_GENERIC_PALM_POSE) { 111 111 - U_LOG_E("Unknown input name: 0x%0x", name); 112 112 - return; 111 111 + U_LOG_XDEV_UNSUPPORTED_INPUT(&rd->base, u_log_get_global_level(), name); 112 112 + return XRT_ERROR_INPUT_UNSUPPORTED; 113 113 } 114 114 115 115 struct r_remote_controller_data *latest = rd->is_left ? &r->latest.left : &r->latest.right; ··· 133 133 } else { 134 134 out_relation->relation_flags = 0; 135 135 } 136 136 + 137 137 + return XRT_SUCCESS; 136 138 } 137 139 138 140 static void

+6 -2

src/xrt/drivers/remote/r_hmd.c

··· 56 56 u_device_free(&rh->base); 57 57 } 58 58 59 59 - static void 59 59 + static xrt_result_t 60 60 r_hmd_get_tracked_pose(struct xrt_device *xdev, 61 61 enum xrt_input_name name, 62 62 int64_t at_timestamp_ns, ··· 66 66 67 67 switch (name) { 68 68 case XRT_INPUT_GENERIC_HEAD_POSE: copy_head_center_to_relation(rh, out_relation); break; 69 69 - default: U_LOG_E("Unknown input name"); break; 69 69 + default: 70 70 + U_LOG_XDEV_UNSUPPORTED_INPUT(&rh->base, u_log_get_global_level(), name); 71 71 + return XRT_ERROR_INPUT_UNSUPPORTED; 70 72 } 73 73 + 74 74 + return XRT_SUCCESS; 71 75 } 72 76 73 77 static void

+5 -3

src/xrt/drivers/rift_s/rift_s_controller.c

··· 539 539 XRT_SPACE_RELATION_ANGULAR_VELOCITY_VALID_BIT | XRT_SPACE_RELATION_LINEAR_VELOCITY_VALID_BIT); 540 540 } 541 541 542 542 - static void 542 542 + static xrt_result_t 543 543 rift_s_controller_get_tracked_pose(struct xrt_device *xdev, 544 544 enum xrt_input_name name, 545 545 int64_t at_timestamp_ns, ··· 548 548 struct rift_s_controller *ctrl = (struct rift_s_controller *)(xdev); 549 549 550 550 if (name != XRT_INPUT_TOUCH_AIM_POSE && name != XRT_INPUT_TOUCH_GRIP_POSE) { 551 551 - RIFT_S_ERROR("unknown pose name requested"); 552 552 - return; 551 551 + U_LOG_XDEV_UNSUPPORTED_INPUT(&ctrl->base, rift_s_log_level, name); 552 552 + return XRT_ERROR_INPUT_UNSUPPORTED; 553 553 } 554 554 555 555 struct xrt_relation_chain xrc = {0}; ··· 571 571 os_mutex_unlock(&ctrl->mutex); 572 572 573 573 m_relation_chain_resolve(&xrc, out_relation); 574 574 + 575 575 + return XRT_SUCCESS; 574 576 } 575 577 576 578 static void

+4 -3

src/xrt/drivers/rift_s/rift_s_hmd.c

··· 43 43 #define DEG_TO_RAD(D) ((D)*M_PI / 180.) 44 44 45 45 46 46 - static void 46 46 + static xrt_result_t 47 47 rift_s_get_tracked_pose(struct xrt_device *xdev, 48 48 enum xrt_input_name name, 49 49 int64_t at_timestamp_ns, ··· 52 52 struct rift_s_hmd *hmd = (struct rift_s_hmd *)(xdev); 53 53 54 54 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 55 55 - RIFT_S_ERROR("Unknown input name"); 56 56 - return; 55 55 + U_LOG_XDEV_UNSUPPORTED_INPUT(&hmd->base, rift_s_log_level, name); 56 56 + return XRT_ERROR_INPUT_UNSUPPORTED; 57 57 } 58 58 59 59 U_ZERO(out_relation); 60 60 61 61 rift_s_tracker_get_tracked_pose(hmd->tracker, RIFT_S_TRACKER_POSE_DEVICE, at_timestamp_ns, out_relation); 62 62 + return XRT_SUCCESS; 62 63 } 63 64 64 65 void

+8 -3

src/xrt/drivers/rift_s/rift_s_tracker.c

··· 67 67 //! Specifies whether the user wants to use the hand tracker. 68 68 DEBUG_GET_ONCE_BOOL_OPTION(rift_s_handtracking, "RIFT_S_HANDTRACKING", true) 69 69 70 70 - static void 70 70 + static xrt_result_t 71 71 rift_s_tracker_get_tracked_pose_imu(struct xrt_device *xdev, 72 72 enum xrt_input_name name, 73 73 int64_t at_timestamp_ns, ··· 608 608 math_quat_rotate_vec3(&q, &pose->position, &pose->position); 609 609 } 610 610 611 611 - static void 611 611 + static xrt_result_t 612 612 rift_s_tracker_get_tracked_pose_imu(struct xrt_device *xdev, 613 613 enum xrt_input_name name, 614 614 int64_t at_timestamp_ns, 615 615 struct xrt_space_relation *out_relation) 616 616 { 617 617 struct rift_s_tracker *tracker = (struct rift_s_tracker *)(xdev); 618 618 - assert(name == XRT_INPUT_GENERIC_TRACKER_POSE); 618 618 + if (name != XRT_INPUT_GENERIC_TRACKER_POSE) { 619 619 + U_LOG_XDEV_UNSUPPORTED_INPUT(&tracker->base, rift_s_log_level, name); 620 620 + return XRT_ERROR_INPUT_UNSUPPORTED; 621 621 + } 619 622 620 623 rift_s_tracker_get_tracked_pose(tracker, RIFT_S_TRACKER_POSE_IMU, at_timestamp_ns, out_relation); 624 624 + 625 625 + return XRT_SUCCESS; 621 626 } 622 627 623 628 void

+5 -3

src/xrt/drivers/rokid/rokid_hmd.c

··· 430 430 u_device_free(&rokid->base); 431 431 } 432 432 433 433 - static void 433 433 + static xrt_result_t 434 434 rokid_hmd_get_tracked_pose(struct xrt_device *xdev, 435 435 enum xrt_input_name name, 436 436 int64_t at_timestamp_ns, ··· 439 439 struct rokid_hmd *rokid = rokid_hmd(xdev); 440 440 441 441 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 442 442 - ROKID_ERROR(rokid, "unknown input name"); 443 443 - return; 442 442 + U_LOG_XDEV_UNSUPPORTED_INPUT(&rokid->base, rokid->log_level, name); 443 443 + return XRT_ERROR_INPUT_UNSUPPORTED; 444 444 } 445 445 os_mutex_lock(&rokid->fusion.mutex); 446 446 rokid_fusion_get_pose(&rokid->fusion, at_timestamp_ns, out_relation); 447 447 os_mutex_unlock(&rokid->fusion.mutex); 448 448 + 449 449 + return XRT_SUCCESS; 448 450 } 449 451 450 452 static struct xrt_device *

+4 -3

src/xrt/drivers/sample/sample_hmd.c

··· 96 96 return XRT_SUCCESS; 97 97 } 98 98 99 99 - static void 99 99 + static xrt_result_t 100 100 sample_hmd_get_tracked_pose(struct xrt_device *xdev, 101 101 enum xrt_input_name name, 102 102 int64_t at_timestamp_ns, ··· 105 105 struct sample_hmd *hmd = sample_hmd(xdev); 106 106 107 107 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 108 108 - HMD_ERROR(hmd, "unknown input name"); 109 109 - return; 108 108 + U_LOG_XDEV_UNSUPPORTED_INPUT(&hmd->base, hmd->log_level, name); 109 109 + return XRT_ERROR_INPUT_UNSUPPORTED; 110 110 } 111 111 112 112 struct xrt_space_relation relation = XRT_SPACE_RELATION_ZERO; ··· 125 125 } 126 126 127 127 *out_relation = relation; 128 128 + return XRT_SUCCESS; 128 129 } 129 130 130 131 static void

+5 -2

src/xrt/drivers/simula/svr_hmd.c

··· 72 72 u_device_free(&ns->base); 73 73 } 74 74 75 75 - static void 75 75 + static xrt_result_t 76 76 svr_hmd_get_tracked_pose(struct xrt_device *xdev, 77 77 enum xrt_input_name name, 78 78 int64_t at_timestamp_ns, ··· 82 82 83 83 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 84 84 SVR_ERROR(ns, "unknown input name"); 85 85 - return; 85 85 + U_LOG_XDEV_UNSUPPORTED_INPUT(&ns->base, ns->log_level, name); 86 86 + return XRT_ERROR_INPUT_UNSUPPORTED; 86 87 } 87 88 88 89 ··· 92 93 (struct xrt_pose)XRT_POSE_IDENTITY; // This is so that tracking overrides/multi driver just transforms us by 93 94 // the tracker + offset from the tracker. 94 95 out_relation->relation_flags = XRT_SPACE_RELATION_BITMASK_ALL; 96 96 + 97 97 + return XRT_SUCCESS; 95 98 } 96 99 97 100 #define DEG_TO_RAD(DEG) (DEG * M_PI / 180.)

+9 -5

src/xrt/drivers/simulated/simulated_controller.c

··· 46 46 #define CHECK_THAT_NAME_IS_AND_ERROR(NAME) \ 47 47 do { \ 48 48 if (sd->base.name != NAME) { \ 49 49 - U_LOG_E("Unknown input for controller %s 0x%02x", #NAME, name); \ 50 50 - return; \ 49 49 + U_LOG_XDEV_UNSUPPORTED_INPUT(&sd->base, u_log_get_global_level(), name); \ 50 50 + return XRT_ERROR_INPUT_UNSUPPORTED; \ 51 51 } \ 52 52 } while (false) 53 53 ··· 118 118 return XRT_SUCCESS; 119 119 } 120 120 121 121 - static void 121 121 + static xrt_result_t 122 122 simulated_device_get_tracked_pose(struct xrt_device *xdev, 123 123 enum xrt_input_name name, 124 124 int64_t at_timestamp_ns, ··· 133 133 case XRT_INPUT_WMR_AIM_POSE: CHECK_THAT_NAME_IS_AND_ERROR(XRT_DEVICE_WMR_CONTROLLER); break; 134 134 case XRT_INPUT_ML2_CONTROLLER_GRIP_POSE: 135 135 case XRT_INPUT_ML2_CONTROLLER_AIM_POSE: CHECK_THAT_NAME_IS_AND_ERROR(XRT_DEVICE_ML2_CONTROLLER); break; 136 136 - default: U_LOG_E("Unknown input name: 0x%0x", name); return; 136 136 + default: 137 137 + U_LOG_XDEV_UNSUPPORTED_INPUT(&sd->base, u_log_get_global_level(), name); 138 138 + return XRT_ERROR_INPUT_UNSUPPORTED; 137 139 } 138 140 139 141 if (!sd->active) { 140 142 out_relation->pose = (struct xrt_pose)XRT_POSE_IDENTITY; 141 143 out_relation->relation_flags = 0; 142 142 - return; 144 144 + return XRT_SUCCESS; 143 145 } 144 146 145 147 struct xrt_pose pose = sd->center; ··· 160 162 XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_POSITION_VALID_BIT | 161 163 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT | 162 164 XRT_SPACE_RELATION_LINEAR_VELOCITY_VALID_BIT | XRT_SPACE_RELATION_ANGULAR_VELOCITY_VALID_BIT); 165 165 + 166 166 + return XRT_SUCCESS; 163 167 } 164 168 165 169 static void

+5 -3

src/xrt/drivers/simulated/simulated_hmd.c

··· 85 85 u_device_free(&dh->base); 86 86 } 87 87 88 88 - static void 88 88 + static xrt_result_t 89 89 simulated_hmd_get_tracked_pose(struct xrt_device *xdev, 90 90 enum xrt_input_name name, 91 91 int64_t at_timestamp_ns, ··· 94 94 struct simulated_hmd *hmd = simulated_hmd(xdev); 95 95 96 96 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 97 97 - HMD_ERROR(hmd, "unknown input name"); 98 98 - return; 97 97 + U_LOG_XDEV_UNSUPPORTED_INPUT(&hmd->base, hmd->log_level, name); 98 98 + return XRT_ERROR_INPUT_UNSUPPORTED; 99 99 } 100 100 101 101 const double time_s = time_ns_to_s(at_timestamp_ns - hmd->created_ns); ··· 142 142 out_relation->relation_flags = (enum xrt_space_relation_flags)(XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | 143 143 XRT_SPACE_RELATION_POSITION_VALID_BIT | 144 144 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT); 145 145 + 146 146 + return XRT_SUCCESS; 145 147 } 146 148 147 149 static xrt_result_t

+7 -3

src/xrt/drivers/steamvr_lh/device.cpp

··· 426 426 return XRT_SUCCESS; 427 427 } 428 428 429 429 - void 429 429 + xrt_result_t 430 430 HmdDevice::get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) 431 431 { 432 432 switch (name) { 433 433 case XRT_INPUT_GENERIC_HEAD_POSE: Device::get_pose(at_timestamp_ns, out_relation); break; 434 434 - default: U_LOG_W("steamvr_lh hmd: Requested pose for unknown name %u", name); break; 434 434 + default: U_LOG_XDEV_UNSUPPORTED_INPUT(this, ctx->log_level, name); return XRT_ERROR_INPUT_UNSUPPORTED; 435 435 } 436 436 + 437 437 + return XRT_SUCCESS; 436 438 } 437 439 438 438 - void 440 440 + xrt_result_t 439 441 ControllerDevice::get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) 440 442 { 441 443 xrt_space_relation rel = {}; ··· 453 455 struct xrt_pose *p = &out_relation->pose; 454 456 DEV_DEBUG("controller %u: GET_POSITION (%f %f %f) GET_ORIENTATION (%f, %f, %f, %f)", name, p->position.x, 455 457 p->position.y, p->position.z, p->orientation.x, p->orientation.y, p->orientation.z, p->orientation.w); 458 458 + 459 459 + return XRT_SUCCESS; 456 460 } 457 461 458 462 void

+3 -3

src/xrt/drivers/steamvr_lh/device.hpp

··· 69 69 handle_properties(const vr::PropertyWrite_t *batch, uint32_t count); 70 70 71 71 //! Maps to @ref xrt_device::get_tracked_pose. 72 72 - virtual void 72 72 + virtual xrt_result_t 73 73 get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) = 0; 74 74 75 75 xrt_result_t ··· 116 116 117 117 HmdDevice(const DeviceBuilder &builder); 118 118 119 119 - void 119 119 + xrt_result_t 120 120 get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) override; 121 121 122 122 void ··· 168 168 void 169 169 set_haptic_handle(vr::VRInputComponentHandle_t handle); 170 170 171 171 - void 171 171 + xrt_result_t 172 172 get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) override; 173 173 174 174 IndexFingerInput *

+5 -4

src/xrt/drivers/survive/survive_driver.c

··· 324 324 return false; 325 325 } 326 326 327 327 - static void 327 327 + static xrt_result_t 328 328 survive_device_get_tracked_pose(struct xrt_device *xdev, 329 329 enum xrt_input_name name, 330 330 int64_t at_timestamp_ns, ··· 332 332 { 333 333 struct survive_device *survive = (struct survive_device *)xdev; 334 334 if (!verify_device_name(survive, name)) { 335 335 - SURVIVE_ERROR(survive, "unknown input name"); 336 336 - return; 335 335 + U_LOG_XDEV_UNSUPPORTED_INPUT(&survive->base, survive->sys->log_level, name); 336 336 + return XRT_ERROR_INPUT_UNSUPPORTED; 337 337 } 338 338 339 339 if (!survive->survive_obj) { 340 340 // U_LOG_D("Obj not set for %p", (void*)survive); 341 341 - return; 341 341 + return XRT_SUCCESS; 342 342 } 343 343 344 344 // We're pretty sure libsurvive is giving us the IMU pose here, so this works. ··· 356 356 struct xrt_pose *p = &out_relation->pose; 357 357 SURVIVE_TRACE(survive, "GET_POSITION (%f %f %f) GET_ORIENTATION (%f, %f, %f, %f)", p->position.x, p->position.y, 358 358 p->position.z, p->orientation.x, p->orientation.y, p->orientation.z, p->orientation.w); 359 359 + return XRT_SUCCESS; 359 360 } 360 361 361 362 static xrt_result_t

+6 -5

src/xrt/drivers/twrap/twrap_slam.c

··· 84 84 } 85 85 #endif 86 86 87 87 - static void 87 87 + static xrt_result_t 88 88 twrap_slam_get_tracked_pose(struct xrt_device *xdev, 89 89 enum xrt_input_name name, 90 90 int64_t at_timestamp_ns, ··· 93 93 struct slam_device *dx = slam_device(xdev); 94 94 95 95 if (name != XRT_INPUT_GENERIC_TRACKER_POSE) { 96 96 - SLAM_ERROR(dx, "unknown input name %d", name); 97 97 - return; 96 96 + U_LOG_XDEV_UNSUPPORTED_INPUT(&dx->base, dx->log_level, name); 97 97 + return XRT_ERROR_INPUT_UNSUPPORTED; 98 98 } 99 99 #ifdef XRT_FEATURE_SLAM 100 100 if (!dx->use_3dof) { ··· 109 109 110 110 if (!pose_tracked) { 111 111 U_ZERO(&out_relation->relation_flags); 112 112 - return; 112 112 + return XRT_SUCCESS; 113 113 } 114 114 115 115 basalt_rel.pose = twrap_hmd_correct_pose_from_basalt(basalt_rel.pose); ··· 127 127 } 128 128 129 129 m_relation_chain_resolve(&xrc, out_relation); 130 130 - return; 130 130 + return XRT_SUCCESS; 131 131 } 132 132 133 133 #endif 134 134 m_relation_history_get(dx->dof3->rh, at_timestamp_ns, out_relation); 135 135 + return XRT_SUCCESS; 135 136 } 136 137 137 138 static void

+5 -3

src/xrt/drivers/vive/vive_controller.c

··· 410 410 out_value->is_active = true; 411 411 } 412 412 413 413 - static void 413 413 + static xrt_result_t 414 414 vive_controller_device_get_tracked_pose(struct xrt_device *xdev, 415 415 enum xrt_input_name name, 416 416 int64_t at_timestamp_ns, ··· 421 421 // U_LOG_D("input name %d %d", name, XRT_INPUT_VIVE_GRIP_POSE); 422 422 if (name != XRT_INPUT_VIVE_AIM_POSE && name != XRT_INPUT_VIVE_GRIP_POSE && name != XRT_INPUT_INDEX_AIM_POSE && 423 423 name != XRT_INPUT_INDEX_GRIP_POSE) { 424 424 - VIVE_ERROR(d, "unknown input name"); 425 425 - return; 424 424 + U_LOG_XDEV_UNSUPPORTED_INPUT(&d->base, d->log_level, name); 425 425 + return XRT_ERROR_INPUT_UNSUPPORTED; 426 426 } 427 427 428 428 get_pose(d, name, at_timestamp_ns, out_relation); 429 429 + 430 430 + return XRT_SUCCESS; 429 431 } 430 432 431 433 static int

+14 -6

src/xrt/drivers/vive/vive_device.c

··· 106 106 return XRT_SUCCESS; 107 107 } 108 108 109 109 - static void 109 109 + static xrt_result_t 110 110 vive_device_get_3dof_tracked_pose(struct xrt_device *xdev, 111 111 enum xrt_input_name name, 112 112 uint64_t at_timestamp_ns, ··· 117 117 struct vive_device *d = vive_device(xdev); 118 118 119 119 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 120 120 - U_LOG_E("unknown input name"); 121 121 - return; 120 120 + U_LOG_XDEV_UNSUPPORTED_INPUT(&d->base, u_log_get_global_level(), name); 121 121 + return XRT_ERROR_INPUT_UNSUPPORTED; 122 122 } 123 123 124 124 struct xrt_space_relation relation = {0}; ··· 131 131 132 132 *out_relation = relation; 133 133 d->pose = out_relation->pose; 134 134 + 135 135 + return XRT_SUCCESS; 134 136 } 135 137 136 138 //! Specific pose corrections for Basalt and a Valve Index headset ··· 179 181 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT); 180 182 } 181 183 182 182 - static void 184 184 + static xrt_result_t 183 185 vive_device_get_tracked_pose(struct xrt_device *xdev, 184 186 enum xrt_input_name name, 185 187 int64_t at_timestamp_ns, ··· 192 194 // Ajdust the timestamp with the offset. 193 195 at_timestamp_ns += (int64_t)(d->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 194 196 197 197 + xrt_result_t xret = XRT_SUCCESS; 195 198 if (d->tracking.slam_enabled && d->slam_over_3dof) { 196 199 vive_device_get_slam_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 197 200 } else { 198 198 - vive_device_get_3dof_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 201 201 + xret = vive_device_get_3dof_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 199 202 } 200 200 - math_pose_transform(&d->offset, &out_relation->pose, &out_relation->pose); 203 203 + 204 204 + if (xret == XRT_SUCCESS) { 205 205 + math_pose_transform(&d->offset, &out_relation->pose, &out_relation->pose); 206 206 + } 207 207 + 208 208 + return xret; 201 209 } 202 210 203 211 static void

+4 -2

src/xrt/drivers/wmr/wmr_controller_base.c

··· 443 443 return true; 444 444 } 445 445 446 446 - static void 446 446 + static xrt_result_t 447 447 wmr_controller_base_get_tracked_pose(struct xrt_device *xdev, 448 448 enum xrt_input_name name, 449 449 int64_t at_timestamp_ns, ··· 479 479 // No prediction needed. 480 480 if (at_timestamp_ns < last_imu_timestamp_ns) { 481 481 *out_relation = relation; 482 482 - return; 482 482 + return XRT_SUCCESS; 483 483 } 484 484 485 485 int64_t prediction_ns = at_timestamp_ns - last_imu_timestamp_ns; 486 486 double prediction_s = time_ns_to_s(prediction_ns); 487 487 488 488 m_predict_relation(&relation, prediction_s, out_relation); 489 489 + 490 490 + return XRT_SUCCESS; 489 491 } 490 492 491 493 void

+15 -7

src/xrt/drivers/wmr/wmr_hmd.c

··· 1073 1073 * 1074 1074 */ 1075 1075 1076 1076 - static void 1076 1076 + static xrt_result_t 1077 1077 wmr_hmd_get_3dof_tracked_pose(struct xrt_device *xdev, 1078 1078 enum xrt_input_name name, 1079 1079 uint64_t at_timestamp_ns, ··· 1084 1084 struct wmr_hmd *wh = wmr_hmd(xdev); 1085 1085 1086 1086 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 1087 1087 - WMR_ERROR(wh, "Unknown input name"); 1088 1088 - return; 1087 1087 + U_LOG_XDEV_UNSUPPORTED_INPUT(&wh->base, wh->log_level, name); 1088 1088 + return XRT_ERROR_INPUT_UNSUPPORTED; 1089 1089 } 1090 1090 1091 1091 // Variables needed for prediction. ··· 1105 1105 // No prediction needed. 1106 1106 if (at_timestamp_ns < last_imu_timestamp_ns) { 1107 1107 *out_relation = relation; 1108 1108 - return; 1108 1108 + return XRT_SUCCESS; 1109 1109 } 1110 1110 1111 1111 uint64_t prediction_ns = at_timestamp_ns - last_imu_timestamp_ns; ··· 1113 1113 1114 1114 m_predict_relation(&relation, prediction_s, out_relation); 1115 1115 wh->pose = out_relation->pose; 1116 1116 + 1117 1117 + return XRT_SUCCESS; 1116 1118 } 1117 1119 1118 1120 //! Specific pose corrections for Basalt and a WMR headset ··· 1165 1167 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT); 1166 1168 } 1167 1169 1168 1168 - static void 1170 1170 + static xrt_result_t 1169 1171 wmr_hmd_get_tracked_pose(struct xrt_device *xdev, 1170 1172 enum xrt_input_name name, 1171 1173 int64_t at_timestamp_ns, ··· 1177 1179 1178 1180 at_timestamp_ns += (int64_t)(wh->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 1179 1181 1182 1182 + xrt_result_t xret = XRT_SUCCESS; 1180 1183 if (wh->tracking.slam_enabled && wh->slam_over_3dof) { 1181 1184 wmr_hmd_get_slam_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 1182 1185 } else { 1183 1183 - wmr_hmd_get_3dof_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 1186 1186 + xret = wmr_hmd_get_3dof_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 1187 1187 + } 1188 1188 + 1189 1189 + if (xret == XRT_SUCCESS) { 1190 1190 + math_pose_transform(&wh->offset, &out_relation->pose, &out_relation->pose); 1184 1191 } 1185 1185 - math_pose_transform(&wh->offset, &out_relation->pose, &out_relation->pose); 1192 1192 + 1193 1193 + return xret; 1186 1194 } 1187 1195 1188 1196 static void

+4 -3

src/xrt/drivers/xreal_air/xreal_air_hmd.c

··· 1049 1049 return XRT_SUCCESS; 1050 1050 } 1051 1051 1052 1052 - static void 1052 1052 + static xrt_result_t 1053 1053 xreal_air_hmd_get_tracked_pose(struct xrt_device *xdev, 1054 1054 enum xrt_input_name name, 1055 1055 int64_t at_timestamp_ns, ··· 1058 1058 struct xreal_air_hmd *hmd = xreal_air_hmd(xdev); 1059 1059 1060 1060 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 1061 1061 - XREAL_AIR_ERROR(hmd, "unknown input name"); 1062 1062 - return; 1061 1061 + U_LOG_XDEV_UNSUPPORTED_INPUT(&hmd->base, hmd->log_level, name); 1062 1062 + return XRT_ERROR_INPUT_UNSUPPORTED; 1063 1063 } 1064 1064 1065 1065 const enum xrt_space_relation_flags flags = (enum xrt_space_relation_flags)( ··· 1076 1076 1077 1077 // Make sure that the orientation is valid. 1078 1078 math_quat_normalize(&out_relation->pose.orientation); 1079 1079 + return XRT_SUCCESS; 1079 1080 } 1080 1081 1081 1082 static void

+5 -6

src/xrt/include/xrt/xrt_device.h

··· 319 319 * 320 320 * @see xrt_input_name 321 321 */ 322 322 - void (*get_tracked_pose)(struct xrt_device *xdev, 323 323 - enum xrt_input_name name, 324 324 - int64_t at_timestamp_ns, 325 325 - struct xrt_space_relation *out_relation); 322 322 + xrt_result_t (*get_tracked_pose)(struct xrt_device *xdev, 323 323 + enum xrt_input_name name, 324 324 + int64_t at_timestamp_ns, 325 325 + struct xrt_space_relation *out_relation); 326 326 327 327 /*! 328 328 * @brief Get relationship of hand joints to the tracking origin space as ··· 580 580 int64_t at_timestamp_ns, 581 581 struct xrt_space_relation *out_relation) 582 582 { 583 583 - xdev->get_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 584 584 - return XRT_SUCCESS; 583 583 + return xdev->get_tracked_pose(xdev, name, at_timestamp_ns, out_relation); 585 584 } 586 585 587 586 /*!

+2 -2

src/xrt/ipc/client/ipc_client_device.c

··· 82 82 IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_update_input"); 83 83 } 84 84 85 85 - static void 85 85 + static xrt_result_t 86 86 ipc_client_device_get_tracked_pose(struct xrt_device *xdev, 87 87 enum xrt_input_name name, 88 88 int64_t at_timestamp_ns, ··· 96 96 name, // 97 97 at_timestamp_ns, // 98 98 out_relation); // 99 99 - IPC_CHK_ONLY_PRINT(icd->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 99 99 + IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 100 100 } 101 101 102 102 static void

+2 -2

src/xrt/ipc/client/ipc_client_hmd.c

··· 149 149 IPC_CHK_ALWAYS_RET(ich->ipc_c, xret, "ipc_call_device_update_input"); 150 150 } 151 151 152 152 - static void 152 152 + static xrt_result_t 153 153 ipc_client_hmd_get_tracked_pose(struct xrt_device *xdev, 154 154 enum xrt_input_name name, 155 155 int64_t at_timestamp_ns, ··· 164 164 name, // 165 165 at_timestamp_ns, // 166 166 out_relation); // 167 167 - IPC_CHK_ONLY_PRINT(ich->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 167 167 + IPC_CHK_ALWAYS_RET(ich->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 168 168 } 169 169 170 170 static void

+5 -3

src/xrt/targets/sdl_test/sdl_device.c

··· 14 14 #include "util/u_distortion_mesh.h" 15 15 16 16 17 17 - static void 17 17 + static xrt_result_t 18 18 sdl_hmd_get_tracked_pose(struct xrt_device *xdev, 19 19 enum xrt_input_name name, 20 20 int64_t at_timestamp_ns, ··· 23 23 struct sdl_program *sp = from_xdev(xdev); 24 24 25 25 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 26 26 - U_LOG_E("Unknown input name"); 27 27 - return; 26 26 + U_LOG_XDEV_UNSUPPORTED_INPUT(&sp->xdev_base, u_log_get_global_level(), name); 27 27 + return XRT_ERROR_INPUT_UNSUPPORTED; 28 28 } 29 29 30 30 struct xrt_space_relation relation = XRT_SPACE_RELATION_ZERO; ··· 37 37 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT; // 38 38 39 39 *out_relation = relation; 40 40 + 41 41 + return XRT_SUCCESS; 40 42 } 41 43 42 44 static void