+1 -1

src/xrt/drivers/android/android_sensors.c

reviewed

··· 173 173 static void 174 174 android_device_get_tracked_pose(struct xrt_device *xdev, 175 175 enum xrt_input_name name, 176 176 - uint64_t at_timestamp_ns, 176 176 + int64_t at_timestamp_ns, 177 177 struct xrt_space_relation *out_relation) 178 178 { 179 179 (void)at_timestamp_ns;

+1 -1

src/xrt/drivers/arduino/arduino_device.c

reviewed

··· 332 332 static void 333 333 arduino_device_get_tracked_pose(struct xrt_device *xdev, 334 334 enum xrt_input_name name, 335 335 - uint64_t at_timestamp_ns, 335 335 + int64_t at_timestamp_ns, 336 336 struct xrt_space_relation *out_relation) 337 337 { 338 338 struct arduino_device *ad = arduino_device(xdev);

+1 -1

src/xrt/drivers/daydream/daydream_device.c

reviewed

··· 311 311 static void 312 312 daydream_device_get_tracked_pose(struct xrt_device *xdev, 313 313 enum xrt_input_name name, 314 314 - uint64_t at_timestamp_ns, 314 314 + int64_t at_timestamp_ns, 315 315 struct xrt_space_relation *out_relation) 316 316 { 317 317 struct daydream_device *daydream = daydream_device(xdev);

+1 -1

src/xrt/drivers/euroc/euroc_device.c

reviewed

··· 105 105 static void 106 106 euroc_device_get_tracked_pose(struct xrt_device *xdev, 107 107 enum xrt_input_name name, 108 108 - uint64_t at_timestamp_ns, 108 108 + int64_t at_timestamp_ns, 109 109 struct xrt_space_relation *out_relation) 110 110 { 111 111 struct euroc_device *ed = euroc_device(xdev);

+1 -1

src/xrt/drivers/hdk/hdk_device.cpp

reviewed

··· 216 216 static void 217 217 hdk_device_get_tracked_pose(struct xrt_device *xdev, 218 218 enum xrt_input_name name, 219 219 - uint64_t requested_timestamp_ns, 219 219 + int64_t requested_timestamp_ns, 220 220 struct xrt_space_relation *out_relation) 221 221 { 222 222 struct hdk_device *hd = hdk_device(xdev);

+5 -5

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

reviewed

··· 217 217 218 218 static void 219 219 get_other_two(struct cemu_device *dev, 220 220 - uint64_t head_timestamp_ns, 221 221 - uint64_t hand_timestamp_ns, 220 220 + int64_t head_timestamp_ns, 221 221 + int64_t hand_timestamp_ns, 222 222 xrt_pose *out_head, 223 223 xrt_hand_joint_set *out_secondary) 224 224 { ··· 242 242 static void 243 243 do_aim_pose(struct cemu_device *dev, 244 244 struct xrt_hand_joint_set *joint_set_primary, 245 245 - uint64_t head_timestamp_ns, 246 246 - uint64_t hand_timestamp_ns, 245 245 + int64_t head_timestamp_ns, 246 246 + int64_t hand_timestamp_ns, 247 247 struct xrt_space_relation *out_relation) 248 248 { 249 249 struct xrt_vec3 vec3_up = {0, 1, 0}; ··· 319 319 static void 320 320 cemu_device_get_tracked_pose(struct xrt_device *xdev, 321 321 enum xrt_input_name name, 322 322 - uint64_t at_timestamp_ns, 322 322 + int64_t at_timestamp_ns, 323 323 struct xrt_space_relation *out_relation) 324 324 { 325 325 struct cemu_device *dev = cemu_device(xdev);

+1 -1

src/xrt/drivers/hydra/hydra_driver.c

reviewed

··· 483 483 static void 484 484 hydra_device_get_tracked_pose(struct xrt_device *xdev, 485 485 enum xrt_input_name name, 486 486 - uint64_t at_timestamp_ns, 486 486 + int64_t at_timestamp_ns, 487 487 struct xrt_space_relation *out_relation) 488 488 { 489 489 struct hydra_device *hd = hydra_device(xdev);

+1 -1

src/xrt/drivers/multi_wrapper/multi.c

reviewed

··· 82 82 static void 83 83 get_tracked_pose(struct xrt_device *xdev, 84 84 enum xrt_input_name name, 85 85 - uint64_t at_timestamp_ns, 85 85 + int64_t at_timestamp_ns, 86 86 struct xrt_space_relation *out_relation) 87 87 { 88 88 struct multi_device *d = (struct multi_device *)xdev;

+1 -1

src/xrt/drivers/north_star/ns_hmd.c

reviewed

··· 370 370 static void 371 371 ns_hmd_get_tracked_pose(struct xrt_device *xdev, 372 372 enum xrt_input_name name, 373 373 - uint64_t at_timestamp_ns, 373 373 + int64_t at_timestamp_ns, 374 374 struct xrt_space_relation *out_relation) 375 375 { 376 376 struct ns_hmd *ns = ns_hmd(xdev);

+1 -1

src/xrt/drivers/ohmd/oh_device.c

reviewed

··· 353 353 static void 354 354 oh_device_get_tracked_pose(struct xrt_device *xdev, 355 355 enum xrt_input_name name, 356 356 - uint64_t at_timestamp_ns, 356 356 + int64_t at_timestamp_ns, 357 357 struct xrt_space_relation *out_relation) 358 358 { 359 359 struct oh_device *ohd = oh_device(xdev);

+1 -1

src/xrt/drivers/psmv/psmv_driver.c

reviewed

··· 909 909 static void 910 910 psmv_device_get_tracked_pose(struct xrt_device *xdev, 911 911 enum xrt_input_name name, 912 912 - uint64_t at_timestamp_ns, 912 912 + int64_t at_timestamp_ns, 913 913 struct xrt_space_relation *out_relation) 914 914 { 915 915 struct xrt_relation_chain xrc = {0};

+2 -2

src/xrt/drivers/pssense/pssense_driver.c

reviewed

··· 733 733 static void 734 734 pssense_get_fusion_pose(struct pssense_device *pssense, 735 735 enum xrt_input_name name, 736 736 - uint64_t at_timestamp_ns, 736 736 + int64_t at_timestamp_ns, 737 737 struct xrt_space_relation *out_relation) 738 738 { 739 739 out_relation->pose = pssense->pose; ··· 758 758 static void 759 759 pssense_get_tracked_pose(struct xrt_device *xdev, 760 760 enum xrt_input_name name, 761 761 - uint64_t at_timestamp_ns, 761 761 + int64_t at_timestamp_ns, 762 762 struct xrt_space_relation *out_relation) 763 763 { 764 764 struct pssense_device *pssense = (struct pssense_device *)xdev;

+1 -1

src/xrt/drivers/psvr/psvr_device.c

reviewed

··· 958 958 static void 959 959 psvr_device_get_tracked_pose(struct xrt_device *xdev, 960 960 enum xrt_input_name name, 961 961 - uint64_t at_timestamp_ns, 961 961 + int64_t at_timestamp_ns, 962 962 struct xrt_space_relation *out_relation) 963 963 { 964 964 struct psvr_device *psvr = psvr_device(xdev);

+1 -1

src/xrt/drivers/qwerty/qwerty_device.c

reviewed

··· 139 139 static void 140 140 qwerty_get_tracked_pose(struct xrt_device *xd, 141 141 enum xrt_input_name name, 142 142 - uint64_t at_timestamp_ns, 142 142 + int64_t at_timestamp_ns, 143 143 struct xrt_space_relation *out_relation) 144 144 { 145 145 struct qwerty_device *qd = qwerty_device(xd);

+1 -1

src/xrt/drivers/realsense/rs_ddev.c

reviewed

··· 391 391 static void 392 392 rs_ddev_get_tracked_pose(struct xrt_device *xdev, 393 393 enum xrt_input_name name, 394 394 - uint64_t at_timestamp_ns, 394 394 + int64_t at_timestamp_ns, 395 395 struct xrt_space_relation *out_relation) 396 396 { 397 397 struct rs_ddev *rs = rs_ddev(xdev);

+1 -1

src/xrt/drivers/realsense/rs_hdev.c

reviewed

··· 276 276 static void 277 277 rs_hdev_get_tracked_pose(struct xrt_device *xdev, 278 278 enum xrt_input_name name, 279 279 - uint64_t at_timestamp_ns, 279 279 + int64_t at_timestamp_ns, 280 280 struct xrt_space_relation *out_relation) 281 281 { 282 282 struct rs_hdev *rh = rs_hdev_from_xdev(xdev);

+1 -1

src/xrt/drivers/remote/r_device.c

reviewed

··· 97 97 static void 98 98 r_device_get_tracked_pose(struct xrt_device *xdev, 99 99 enum xrt_input_name name, 100 100 - uint64_t at_timestamp_ns, 100 100 + int64_t at_timestamp_ns, 101 101 struct xrt_space_relation *out_relation) 102 102 { 103 103 struct r_device *rd = r_device(xdev);

+1 -1

src/xrt/drivers/remote/r_hmd.c

reviewed

··· 59 59 static void 60 60 r_hmd_get_tracked_pose(struct xrt_device *xdev, 61 61 enum xrt_input_name name, 62 62 - uint64_t at_timestamp_ns, 62 62 + int64_t at_timestamp_ns, 63 63 struct xrt_space_relation *out_relation) 64 64 { 65 65 struct r_hmd *rh = r_hmd(xdev);

+2 -2

src/xrt/drivers/rift_s/rift_s_controller.c

reviewed

··· 517 517 static void 518 518 rift_s_controller_get_fusion_pose(struct rift_s_controller *ctrl, 519 519 enum xrt_input_name name, 520 520 - uint64_t at_timestamp_ns, 520 520 + int64_t at_timestamp_ns, 521 521 struct xrt_space_relation *out_relation) 522 522 { 523 523 out_relation->pose = ctrl->pose; ··· 541 541 static void 542 542 rift_s_controller_get_tracked_pose(struct xrt_device *xdev, 543 543 enum xrt_input_name name, 544 544 - uint64_t at_timestamp_ns, 544 544 + int64_t at_timestamp_ns, 545 545 struct xrt_space_relation *out_relation) 546 546 { 547 547 struct rift_s_controller *ctrl = (struct rift_s_controller *)(xdev);

+1 -1

src/xrt/drivers/rift_s/rift_s_hmd.c

reviewed

··· 46 46 static void 47 47 rift_s_get_tracked_pose(struct xrt_device *xdev, 48 48 enum xrt_input_name name, 49 49 - uint64_t at_timestamp_ns, 49 49 + int64_t at_timestamp_ns, 50 50 struct xrt_space_relation *out_relation) 51 51 { 52 52 struct rift_s_hmd *hmd = (struct rift_s_hmd *)(xdev);

+2 -2

src/xrt/drivers/rift_s/rift_s_tracker.c

reviewed

··· 70 70 static void 71 71 rift_s_tracker_get_tracked_pose_imu(struct xrt_device *xdev, 72 72 enum xrt_input_name name, 73 73 - uint64_t at_timestamp_ns, 73 73 + int64_t at_timestamp_ns, 74 74 struct xrt_space_relation *out_relation); 75 75 76 76 static void ··· 611 611 static void 612 612 rift_s_tracker_get_tracked_pose_imu(struct xrt_device *xdev, 613 613 enum xrt_input_name name, 614 614 - uint64_t at_timestamp_ns, 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);

+4 -4

src/xrt/drivers/rokid/rokid_hmd.c

reviewed

··· 54 54 struct os_mutex mutex; 55 55 struct m_imu_3dof i3dof; 56 56 struct xrt_space_relation last_relation; 57 57 - uint64_t last_update; 57 57 + int64_t last_update; 58 58 struct xrt_vec3 last_gyro; 59 59 struct xrt_vec3 last_accel; 60 60 uint64_t gyro_ts_device; ··· 232 232 233 233 234 234 static void 235 235 - rokid_fusion_get_pose(struct rokid_fusion *fusion, uint64_t at_timestamp_ns, struct xrt_space_relation *out_relation) 235 235 + rokid_fusion_get_pose(struct rokid_fusion *fusion, int64_t at_timestamp_ns, struct xrt_space_relation *out_relation) 236 236 { 237 237 if (at_timestamp_ns > fusion->last_update) { 238 238 double time_diff = time_ns_to_s(at_timestamp_ns - fusion->last_update); ··· 261 261 u_var_add_pose(root, &fusion->last_relation.pose, "last_pose"); 262 262 u_var_add_ro_vec3_f32(root, &fusion->last_gyro, "gyro"); 263 263 u_var_add_ro_vec3_f32(root, &fusion->last_accel, "accel"); 264 264 - u_var_add_ro_u64(root, &fusion->last_update, "timestamp"); 264 264 + u_var_add_ro_i64(root, &fusion->last_update, "timestamp"); 265 265 } 266 266 267 267 ··· 433 433 static void 434 434 rokid_hmd_get_tracked_pose(struct xrt_device *xdev, 435 435 enum xrt_input_name name, 436 436 - uint64_t at_timestamp_ns, 436 436 + int64_t at_timestamp_ns, 437 437 struct xrt_space_relation *out_relation) 438 438 { 439 439 struct rokid_hmd *rokid = rokid_hmd(xdev);

+1 -1

src/xrt/drivers/sample/sample_hmd.c

reviewed

··· 98 98 static void 99 99 sample_hmd_get_tracked_pose(struct xrt_device *xdev, 100 100 enum xrt_input_name name, 101 101 - uint64_t at_timestamp_ns, 101 101 + int64_t at_timestamp_ns, 102 102 struct xrt_space_relation *out_relation) 103 103 { 104 104 struct sample_hmd *hmd = sample_hmd(xdev);

+1 -1

src/xrt/drivers/simula/svr_hmd.c

reviewed

··· 75 75 static void 76 76 svr_hmd_get_tracked_pose(struct xrt_device *xdev, 77 77 enum xrt_input_name name, 78 78 - uint64_t at_timestamp_ns, 78 78 + int64_t at_timestamp_ns, 79 79 struct xrt_space_relation *out_relation) 80 80 { 81 81 struct svr_hmd *ns = svr_hmd(xdev);

+1 -1

src/xrt/drivers/simulated/simulated_controller.c

reviewed

··· 118 118 static void 119 119 simulated_device_get_tracked_pose(struct xrt_device *xdev, 120 120 enum xrt_input_name name, 121 121 - uint64_t at_timestamp_ns, 121 121 + int64_t at_timestamp_ns, 122 122 struct xrt_space_relation *out_relation) 123 123 { 124 124 struct simulated_device *sd = simulated_device(xdev);

+1 -1

src/xrt/drivers/simulated/simulated_hmd.c

reviewed

··· 88 88 static void 89 89 simulated_hmd_get_tracked_pose(struct xrt_device *xdev, 90 90 enum xrt_input_name name, 91 91 - uint64_t at_timestamp_ns, 91 91 + int64_t at_timestamp_ns, 92 92 struct xrt_space_relation *out_relation) 93 93 { 94 94 struct simulated_hmd *hmd = simulated_hmd(xdev);

+1 -1

src/xrt/drivers/survive/survive_driver.c

reviewed

··· 327 327 static void 328 328 survive_device_get_tracked_pose(struct xrt_device *xdev, 329 329 enum xrt_input_name name, 330 330 - uint64_t at_timestamp_ns, 330 330 + int64_t at_timestamp_ns, 331 331 struct xrt_space_relation *out_relation) 332 332 { 333 333 struct survive_device *survive = (struct survive_device *)xdev;

+1 -1

src/xrt/drivers/twrap/twrap_slam.c

reviewed

··· 87 87 static void 88 88 twrap_slam_get_tracked_pose(struct xrt_device *xdev, 89 89 enum xrt_input_name name, 90 90 - uint64_t at_timestamp_ns, 90 90 + int64_t at_timestamp_ns, 91 91 struct xrt_space_relation *out_relation) 92 92 { 93 93 struct slam_device *dx = slam_device(xdev);

+2 -2

src/xrt/drivers/vive/vive_controller.c

reviewed

··· 123 123 static inline void 124 124 get_pose(struct vive_controller_device *d, 125 125 enum xrt_input_name name, 126 126 - uint64_t at_timestamp_ns, 126 126 + int64_t at_timestamp_ns, 127 127 struct xrt_space_relation *out_relation) 128 128 { 129 129 struct xrt_space_relation imu_relation = {0}; ··· 409 409 static void 410 410 vive_controller_device_get_tracked_pose(struct xrt_device *xdev, 411 411 enum xrt_input_name name, 412 412 - uint64_t at_timestamp_ns, 412 412 + int64_t at_timestamp_ns, 413 413 struct xrt_space_relation *out_relation) 414 414 { 415 415 struct vive_controller_device *d = vive_controller_device(xdev);

+2 -2

src/xrt/drivers/vive/vive_device.c

reviewed

··· 180 180 static void 181 181 vive_device_get_tracked_pose(struct xrt_device *xdev, 182 182 enum xrt_input_name name, 183 183 - uint64_t at_timestamp_ns, 183 183 + int64_t at_timestamp_ns, 184 184 struct xrt_space_relation *out_relation) 185 185 { 186 186 XRT_TRACE_MARKER(); ··· 188 188 struct vive_device *d = vive_device(xdev); 189 189 190 190 // Ajdust the timestamp with the offset. 191 191 - at_timestamp_ns += (uint64_t)(d->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 191 191 + at_timestamp_ns += (int64_t)(d->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 192 192 193 193 if (d->tracking.slam_enabled && d->slam_over_3dof) { 194 194 vive_device_get_slam_tracked_pose(xdev, name, at_timestamp_ns, out_relation);

+3 -3

src/xrt/drivers/wmr/wmr_controller_base.c

reviewed

··· 446 446 static void 447 447 wmr_controller_base_get_tracked_pose(struct xrt_device *xdev, 448 448 enum xrt_input_name name, 449 449 - uint64_t at_timestamp_ns, 449 449 + int64_t at_timestamp_ns, 450 450 struct xrt_space_relation *out_relation) 451 451 { 452 452 DRV_TRACE_MARKER(); ··· 454 454 struct wmr_controller_base *wcb = wmr_controller_base(xdev); 455 455 456 456 // Variables needed for prediction. 457 457 - uint64_t last_imu_timestamp_ns = 0; 457 457 + int64_t last_imu_timestamp_ns = 0; 458 458 struct xrt_space_relation relation = {0}; 459 459 relation.relation_flags = (enum xrt_space_relation_flags)( 460 460 XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | ··· 482 482 return; 483 483 } 484 484 485 485 - uint64_t prediction_ns = at_timestamp_ns - last_imu_timestamp_ns; 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);

+2 -2

src/xrt/drivers/wmr/wmr_hmd.c

reviewed

··· 1168 1168 static void 1169 1169 wmr_hmd_get_tracked_pose(struct xrt_device *xdev, 1170 1170 enum xrt_input_name name, 1171 1171 - uint64_t at_timestamp_ns, 1171 1171 + int64_t at_timestamp_ns, 1172 1172 struct xrt_space_relation *out_relation) 1173 1173 { 1174 1174 DRV_TRACE_MARKER(); 1175 1175 1176 1176 struct wmr_hmd *wh = wmr_hmd(xdev); 1177 1177 1178 1178 - at_timestamp_ns += (uint64_t)(wh->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 1178 1178 + at_timestamp_ns += (int64_t)(wh->tracked_offset_ms.val * (double)U_TIME_1MS_IN_NS); 1179 1179 1180 1180 if (wh->tracking.slam_enabled && wh->slam_over_3dof) { 1181 1181 wmr_hmd_get_slam_tracked_pose(xdev, name, at_timestamp_ns, out_relation);

+1 -1

src/xrt/drivers/xreal_air/xreal_air_hmd.c

reviewed

··· 1050 1050 static void 1051 1051 xreal_air_hmd_get_tracked_pose(struct xrt_device *xdev, 1052 1052 enum xrt_input_name name, 1053 1053 - uint64_t at_timestamp_ns, 1053 1053 + int64_t at_timestamp_ns, 1054 1054 struct xrt_space_relation *out_relation) 1055 1055 { 1056 1056 struct xreal_air_hmd *hmd = xreal_air_hmd(xdev);

+2 -2

src/xrt/include/xrt/xrt_device.h

reviewed

··· 310 310 */ 311 311 void (*get_tracked_pose)(struct xrt_device *xdev, 312 312 enum xrt_input_name name, 313 313 - uint64_t at_timestamp_ns, 313 313 + int64_t at_timestamp_ns, 314 314 struct xrt_space_relation *out_relation); 315 315 316 316 /*! ··· 547 547 static inline void 548 548 xrt_device_get_tracked_pose(struct xrt_device *xdev, 549 549 enum xrt_input_name name, 550 550 - uint64_t at_timestamp_ns, 550 550 + int64_t at_timestamp_ns, 551 551 struct xrt_space_relation *out_relation) 552 552 { 553 553 xdev->get_tracked_pose(xdev, name, at_timestamp_ns, out_relation);

+1 -1

src/xrt/ipc/client/ipc_client_device.c

reviewed

··· 85 85 static void 86 86 ipc_client_device_get_tracked_pose(struct xrt_device *xdev, 87 87 enum xrt_input_name name, 88 88 - uint64_t at_timestamp_ns, 88 88 + int64_t at_timestamp_ns, 89 89 struct xrt_space_relation *out_relation) 90 90 { 91 91 ipc_client_device_t *icd = ipc_client_device(xdev);

+1 -1

src/xrt/ipc/client/ipc_client_hmd.c

reviewed

··· 152 152 static void 153 153 ipc_client_hmd_get_tracked_pose(struct xrt_device *xdev, 154 154 enum xrt_input_name name, 155 155 - uint64_t at_timestamp_ns, 155 155 + int64_t at_timestamp_ns, 156 156 struct xrt_space_relation *out_relation) 157 157 { 158 158 ipc_client_hmd_t *ich = ipc_client_hmd(xdev);

+1 -1

src/xrt/ipc/server/ipc_server_handler.c

reviewed

··· 1854 1854 ipc_handle_device_get_tracked_pose(volatile struct ipc_client_state *ics, 1855 1855 uint32_t id, 1856 1856 enum xrt_input_name name, 1857 1857 - uint64_t at_timestamp, 1857 1857 + int64_t at_timestamp, 1858 1858 struct xrt_space_relation *out_relation) 1859 1859 { 1860 1860 // To make the code a bit more readable.

+1 -1

src/xrt/ipc/shared/proto.json

reviewed

··· 395 395 "in": [ 396 396 {"name": "id", "type": "uint32_t"}, 397 397 {"name": "name", "type": "enum xrt_input_name"}, 398 398 - {"name": "at_timestamp", "type": "uint64_t"} 398 398 + {"name": "at_timestamp", "type": "int64_t"} 399 399 ], 400 400 "out": [ 401 401 {"name": "relation", "type": "struct xrt_space_relation"}

+1 -1

src/xrt/targets/sdl_test/sdl_device.c

reviewed

··· 17 17 static void 18 18 sdl_hmd_get_tracked_pose(struct xrt_device *xdev, 19 19 enum xrt_input_name name, 20 20 - uint64_t at_timestamp_ns, 20 20 + int64_t at_timestamp_ns, 21 21 struct xrt_space_relation *out_relation) 22 22 { 23 23 struct sdl_program *sp = from_xdev(xdev);