-11

src/xrt/drivers/android/android_sensors.c

reviewed

··· 169 169 } 170 170 171 171 static void 172 172 - android_device_get_view_pose(struct xrt_device *xdev, 173 173 - const struct xrt_vec3 *eye_relation, 174 174 - uint32_t view_index, 175 175 - struct xrt_pose *out_pose) 176 176 - { 177 177 - (void)xdev; 178 178 - u_device_get_view_pose(eye_relation, view_index, out_pose); 179 179 - } 180 180 - 181 181 - static void 182 172 android_device_get_view_poses(struct xrt_device *xdev, 183 173 const struct xrt_vec3 *default_eye_relation, 184 174 uint64_t at_timestamp_ns, ··· 217 207 d->base.destroy = android_device_destroy; 218 208 d->base.update_inputs = android_device_update_inputs; 219 209 d->base.get_tracked_pose = android_device_get_tracked_pose; 220 220 - d->base.get_view_pose = android_device_get_view_pose; 221 210 d->base.get_view_poses = android_device_get_view_poses; 222 211 d->base.compute_distortion = android_device_compute_distortion; 223 212 d->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;

-11

src/xrt/drivers/dummy/dummy_hmd.c

reviewed

··· 144 144 } 145 145 146 146 static void 147 147 - dummy_hmd_get_view_pose(struct xrt_device *xdev, 148 148 - const struct xrt_vec3 *eye_relation, 149 149 - uint32_t view_index, 150 150 - struct xrt_pose *out_pose) 151 151 - { 152 152 - (void)xdev; 153 153 - u_device_get_view_pose(eye_relation, view_index, out_pose); 154 154 - } 155 155 - 156 156 - static void 157 147 dummy_hmd_get_view_poses(struct xrt_device *xdev, 158 148 const struct xrt_vec3 *default_eye_relation, 159 149 uint64_t at_timestamp_ns, ··· 174 164 struct dummy_hmd *dh = U_DEVICE_ALLOCATE(struct dummy_hmd, flags, 1, 0); 175 165 dh->base.update_inputs = dummy_hmd_update_inputs; 176 166 dh->base.get_tracked_pose = dummy_hmd_get_tracked_pose; 177 177 - dh->base.get_view_pose = dummy_hmd_get_view_pose; 178 167 dh->base.get_view_poses = dummy_hmd_get_view_poses; 179 168 dh->base.destroy = dummy_hmd_destroy; 180 169 dh->base.name = XRT_DEVICE_GENERIC_HMD;

-11

src/xrt/drivers/euroc/euroc_device.c

reviewed

··· 160 160 } 161 161 162 162 static void 163 163 - euroc_get_view_pose(struct xrt_device *xdev, 164 164 - const struct xrt_vec3 *eye_relation, 165 165 - uint32_t view_index, 166 166 - struct xrt_pose *out_pose) 167 167 - { 168 168 - (void)xdev; 169 169 - u_device_get_view_pose(eye_relation, view_index, out_pose); 170 170 - } 171 171 - 172 172 - static void 173 163 euroc_get_view_poses(struct xrt_device *xdev, 174 164 const struct xrt_vec3 *default_eye_relation, 175 165 uint64_t at_timestamp_ns, ··· 261 251 xd->get_tracked_pose = euroc_device_get_tracked_pose; 262 252 xd->destroy = euroc_device_destroy; 263 253 if (is_hmd) { 264 264 - xd->get_view_pose = euroc_get_view_pose; 265 254 xd->get_view_poses = euroc_get_view_poses; 266 255 } 267 256

-11

src/xrt/drivers/hdk/hdk_device.cpp

reviewed

··· 254 254 } 255 255 256 256 static void 257 257 - hdk_device_get_view_pose(struct xrt_device *xdev, 258 258 - const struct xrt_vec3 *eye_relation, 259 259 - uint32_t view_index, 260 260 - struct xrt_pose *out_pose) 261 261 - { 262 262 - (void)xdev; 263 263 - u_device_get_view_pose(eye_relation, view_index, out_pose); 264 264 - } 265 265 - 266 266 - static void 267 257 hdk_device_get_view_poses(struct xrt_device *xdev, 268 258 const struct xrt_vec3 *default_eye_relation, 269 259 uint64_t at_timestamp_ns, ··· 318 308 319 309 hd->base.update_inputs = hdk_device_update_inputs; 320 310 hd->base.get_tracked_pose = hdk_device_get_tracked_pose; 321 321 - hd->base.get_view_pose = hdk_device_get_view_pose; 322 311 hd->base.get_view_poses = hdk_device_get_view_poses; 323 312 hd->base.destroy = hdk_device_destroy; 324 313 hd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;

-10

src/xrt/drivers/illixr/illixr_device.cpp

reviewed

··· 131 131 } 132 132 133 133 static void 134 134 - illixr_hmd_get_view_pose(struct xrt_device *xdev, 135 135 - const struct xrt_vec3 *eye_relation, 136 136 - uint32_t view_index, 137 137 - struct xrt_pose *out_pose) 138 138 - { 139 139 - (void)xdev; 140 140 - u_device_get_view_pose(eye_relation, view_index, out_pose); 141 141 - } 142 142 - 143 143 - static void 144 134 illixr_hmd_get_view_poses(struct xrt_device *xdev, 145 135 const struct xrt_vec3 *default_eye_relation, 146 136 uint64_t at_timestamp_ns,

-12

src/xrt/drivers/multi_wrapper/multi.c

reviewed

··· 183 183 } 184 184 185 185 static void 186 186 - get_view_pose(struct xrt_device *xdev, 187 187 - const struct xrt_vec3 *eye_relation, 188 188 - uint32_t view_index, 189 189 - struct xrt_pose *out_pose) 190 190 - { 191 191 - struct multi_device *d = (struct multi_device *)xdev; 192 192 - struct xrt_device *target = d->tracking_override.target; 193 193 - xrt_device_get_view_pose(target, eye_relation, view_index, out_pose); 194 194 - } 195 195 - 196 196 - static void 197 186 get_view_poses(struct xrt_device *xdev, 198 187 const struct xrt_vec3 *default_eye_relation, 199 188 uint64_t at_timestamp_ns, ··· 267 256 d->base.set_output = set_output; 268 257 d->base.update_inputs = update_inputs; 269 258 d->base.compute_distortion = compute_distortion; 270 270 - d->base.get_view_pose = get_view_pose; 271 259 d->base.get_view_poses = get_view_poses; 272 260 273 261 return &d->base;

-11

src/xrt/drivers/north_star/ns_hmd.c

reviewed

··· 455 455 } 456 456 457 457 static void 458 458 - ns_hmd_get_view_pose(struct xrt_device *xdev, 459 459 - const struct xrt_vec3 *eye_relation, 460 460 - uint32_t view_index, 461 461 - struct xrt_pose *out_pose) 462 462 - { 463 463 - struct ns_hmd *ns = ns_hmd(xdev); 464 464 - *out_pose = ns->head_pose_to_eye[view_index]; 465 465 - } 466 466 - 467 467 - static void 468 458 ns_hmd_get_view_poses(struct xrt_device *xdev, 469 459 const struct xrt_vec3 *default_eye_relation, 470 460 uint64_t at_timestamp_ns, ··· 587 577 588 578 ns->base.update_inputs = ns_hmd_update_inputs; 589 579 ns->base.get_tracked_pose = ns_hmd_get_tracked_pose; 590 590 - ns->base.get_view_pose = ns_hmd_get_view_pose; 591 580 ns->base.get_view_poses = ns_hmd_get_view_poses; 592 581 ns->base.destroy = ns_hmd_destroy; 593 582 ns->base.name = XRT_DEVICE_GENERIC_HMD;

-12

src/xrt/drivers/ohmd/oh_device.c

reviewed

··· 428 428 } 429 429 430 430 static void 431 431 - oh_device_get_view_pose(struct xrt_device *xdev, 432 432 - const struct xrt_vec3 *eye_relation, 433 433 - uint32_t view_index, 434 434 - struct xrt_pose *out_pose) 435 435 - { 436 436 - (void)xdev; 437 437 - u_device_get_view_pose(eye_relation, view_index, out_pose); 438 438 - } 439 439 - 440 440 - static void 441 431 oh_device_get_view_poses(struct xrt_device *xdev, 442 432 const struct xrt_vec3 *default_eye_relation, 443 433 uint64_t at_timestamp_ns, ··· 729 719 struct oh_device *ohd = U_DEVICE_ALLOCATE(struct oh_device, flags, 1, 0); 730 720 ohd->base.update_inputs = oh_device_update_inputs; 731 721 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 732 732 - ohd->base.get_view_pose = oh_device_get_view_pose; 733 722 ohd->base.get_view_poses = oh_device_get_view_poses; 734 723 ohd->base.destroy = oh_device_destroy; 735 724 ohd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; ··· 1046 1035 ohd->base.update_inputs = oh_device_update_inputs; 1047 1036 ohd->base.set_output = oh_device_set_output; 1048 1037 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 1049 1049 - ohd->base.get_view_pose = oh_device_get_view_pose; 1050 1038 ohd->base.get_view_poses = oh_device_get_view_poses; 1051 1039 ohd->base.destroy = oh_device_destroy; 1052 1040 if (oculus_touch) {

-11

src/xrt/drivers/psvr/psvr_device.c

reviewed

··· 928 928 } 929 929 930 930 static void 931 931 - psvr_device_get_view_pose(struct xrt_device *xdev, 932 932 - const struct xrt_vec3 *eye_relation, 933 933 - uint32_t view_index, 934 934 - struct xrt_pose *out_pose) 935 935 - { 936 936 - (void)xdev; 937 937 - u_device_get_view_pose(eye_relation, view_index, out_pose); 938 938 - } 939 939 - 940 940 - static void 941 931 psvr_device_get_view_poses(struct xrt_device *xdev, 942 932 const struct xrt_vec3 *default_eye_relation, 943 933 uint64_t at_timestamp_ns, ··· 988 978 psvr->log_level = log_level; 989 979 psvr->base.update_inputs = psvr_device_update_inputs; 990 980 psvr->base.get_tracked_pose = psvr_device_get_tracked_pose; 991 991 - psvr->base.get_view_pose = psvr_device_get_view_pose; 992 981 psvr->base.get_view_poses = psvr_device_get_view_poses; 993 982 psvr->base.compute_distortion = psvr_compute_distortion; 994 983 psvr->base.destroy = psvr_device_destroy;

-11

src/xrt/drivers/qwerty/qwerty_device.c

reviewed

··· 204 204 } 205 205 206 206 static void 207 207 - qwerty_get_view_pose(struct xrt_device *xdev, 208 208 - const struct xrt_vec3 *eye_relation, 209 209 - uint32_t view_index, 210 210 - struct xrt_pose *out_pose) 211 211 - { 212 212 - (void)xdev; 213 213 - u_device_get_view_pose(eye_relation, view_index, out_pose); 214 214 - } 215 215 - 216 216 - static void 217 207 qwerty_get_view_poses(struct xrt_device *xdev, 218 208 const struct xrt_vec3 *default_eye_relation, 219 209 uint64_t at_timestamp_ns, ··· 282 272 283 273 xd->update_inputs = qwerty_update_inputs; 284 274 xd->get_tracked_pose = qwerty_get_tracked_pose; 285 285 - xd->get_view_pose = qwerty_get_view_pose; 286 275 xd->get_view_poses = qwerty_get_view_poses; 287 276 xd->destroy = qwerty_destroy; 288 277 u_distortion_mesh_set_none(xd); // Fill in xd->compute_distortion()

-10

src/xrt/drivers/realsense/rs_ddev.c

reviewed

··· 412 412 } 413 413 414 414 static void 415 415 - rs_ddev_get_view_pose(struct xrt_device *xdev, 416 416 - const struct xrt_vec3 *eye_relation, 417 417 - uint32_t view_index, 418 418 - struct xrt_pose *out_pose) 419 419 - { 420 420 - assert(false); 421 421 - } 422 422 - 423 423 - static void 424 415 rs_ddev_get_view_poses(struct xrt_device *xdev, 425 416 const struct xrt_vec3 *default_eye_relation, 426 417 uint64_t at_timestamp_ns, ··· 477 468 rs->enable_relocalization, rs->enable_pose_prediction, rs->enable_pose_filtering); 478 469 rs->base.update_inputs = rs_ddev_update_inputs; 479 470 rs->base.get_tracked_pose = rs_ddev_get_tracked_pose; 480 480 - rs->base.get_view_pose = rs_ddev_get_view_pose; 481 471 rs->base.get_view_poses = rs_ddev_get_view_poses; 482 472 rs->base.destroy = rs_ddev_destroy; 483 473 rs->base.name = XRT_DEVICE_REALSENSE;

-11

src/xrt/drivers/remote/r_device.c

reviewed

··· 152 152 } 153 153 154 154 static void 155 155 - r_device_get_view_pose(struct xrt_device *xdev, 156 156 - const struct xrt_vec3 *eye_relation, 157 157 - uint32_t view_index, 158 158 - struct xrt_pose *out_pose) 159 159 - { 160 160 - // Empty 161 161 - assert(false); 162 162 - } 163 163 - 164 164 - static void 165 155 r_device_get_view_poses(struct xrt_device *xdev, 166 156 const struct xrt_vec3 *default_eye_relation, 167 157 uint64_t at_timestamp_ns, ··· 197 187 rd->base.update_inputs = r_device_update_inputs; 198 188 rd->base.get_tracked_pose = r_device_get_tracked_pose; 199 189 rd->base.get_hand_tracking = r_device_get_hand_tracking; 200 200 - rd->base.get_view_pose = r_device_get_view_pose; 201 190 rd->base.get_view_poses = r_device_get_view_poses; 202 191 rd->base.set_output = r_device_set_output; 203 192 rd->base.destroy = r_device_destroy;

-11

src/xrt/drivers/remote/r_hmd.c

reviewed

··· 85 85 } 86 86 87 87 static void 88 88 - r_hmd_get_view_pose(struct xrt_device *xdev, 89 89 - const struct xrt_vec3 *eye_relation, 90 90 - uint32_t view_index, 91 91 - struct xrt_pose *out_pose) 92 92 - { 93 93 - (void)xdev; 94 94 - u_device_get_view_pose(eye_relation, view_index, out_pose); 95 95 - } 96 96 - 97 97 - static void 98 88 r_hmd_get_view_poses(struct xrt_device *xdev, 99 89 const struct xrt_vec3 *default_eye_relation, 100 90 uint64_t at_timestamp_ns, ··· 130 120 rh->base.update_inputs = r_hmd_update_inputs; 131 121 rh->base.get_tracked_pose = r_hmd_get_tracked_pose; 132 122 rh->base.get_hand_tracking = r_hmd_get_hand_tracking; 133 133 - rh->base.get_view_pose = r_hmd_get_view_pose; 134 123 rh->base.get_view_poses = r_hmd_get_view_poses; 135 124 rh->base.set_output = r_hmd_set_output; 136 125 rh->base.destroy = r_hmd_destroy;

-12

src/xrt/drivers/sample/sample_hmd.c

reviewed

··· 103 103 } 104 104 105 105 static void 106 106 - sample_hmd_get_view_pose(struct xrt_device *xdev, 107 107 - const struct xrt_vec3 *eye_relation, 108 108 - uint32_t view_index, 109 109 - struct xrt_pose *out_pose) 110 110 - { 111 111 - (void)xdev; 112 112 - // This helper function assumes a symmetric IPD 113 113 - u_device_get_view_pose(eye_relation, view_index, out_pose); 114 114 - } 115 115 - 116 116 - static void 117 106 sample_hmd_get_view_poses(struct xrt_device *xdev, 118 107 const struct xrt_vec3 *default_eye_relation, 119 108 uint64_t at_timestamp_ns, ··· 136 125 struct sample_hmd *sh = U_DEVICE_ALLOCATE(struct sample_hmd, flags, 1, 0); 137 126 sh->base.update_inputs = sample_hmd_update_inputs; 138 127 sh->base.get_tracked_pose = sample_hmd_get_tracked_pose; 139 139 - sh->base.get_view_pose = sample_hmd_get_view_pose; 140 128 sh->base.get_view_poses = sample_hmd_get_view_poses; 141 129 sh->base.destroy = sample_hmd_destroy; 142 130 sh->base.name = XRT_DEVICE_GENERIC_HMD;

-17

src/xrt/drivers/survive/survive_driver.c

reviewed

··· 449 449 } 450 450 451 451 static void 452 452 - survive_device_get_view_pose(struct xrt_device *xdev, 453 453 - const struct xrt_vec3 *eye_relation, 454 454 - uint32_t view_index, 455 455 - struct xrt_pose *out_pose) 456 456 - { 457 457 - // Only supports two views. 458 458 - assert(view_index < 2); 459 459 - 460 460 - u_device_get_view_pose(eye_relation, view_index, out_pose); 461 461 - 462 462 - // This is for the Index' canted displays, on the Vive [Pro] they are identity. 463 463 - struct survive_device *survive = (struct survive_device *)xdev; 464 464 - out_pose->orientation = survive->hmd.config.display.rot[view_index]; 465 465 - } 466 466 - 467 467 - static void 468 452 survive_device_get_view_poses(struct xrt_device *xdev, 469 453 const struct xrt_vec3 *default_eye_relation, 470 454 uint64_t at_timestamp_ns, ··· 856 840 survive->base.destroy = survive_device_destroy; 857 841 survive->base.update_inputs = survive_device_update_inputs; 858 842 survive->base.get_tracked_pose = survive_device_get_tracked_pose; 859 859 - survive->base.get_view_pose = survive_device_get_view_pose; 860 843 survive->base.get_view_poses = survive_device_get_view_poses; 861 844 survive->base.tracking_origin = &sys->base; 862 845

-19

src/xrt/drivers/vive/vive_device.c

reviewed

··· 117 117 } 118 118 119 119 static void 120 120 - vive_device_get_view_pose(struct xrt_device *xdev, 121 121 - const struct xrt_vec3 *eye_relation, 122 122 - uint32_t view_index, 123 123 - struct xrt_pose *out_pose) 124 124 - { 125 125 - XRT_TRACE_MARKER(); 126 126 - 127 127 - // Only supports two views. 128 128 - assert(view_index < 2); 129 129 - 130 130 - u_device_get_view_pose(eye_relation, view_index, out_pose); 131 131 - 132 132 - // This is for the Index' canted displays, on the Vive [Pro] they are identity. 133 133 - struct vive_device *d = vive_device(xdev); 134 134 - out_pose->orientation = d->config.display.rot[view_index]; 135 135 - } 136 136 - 137 137 - static void 138 120 vive_device_get_view_poses(struct xrt_device *xdev, 139 121 const struct xrt_vec3 *default_eye_relation, 140 122 uint64_t at_timestamp_ns, ··· 779 761 780 762 d->base.update_inputs = vive_device_update_inputs; 781 763 d->base.get_tracked_pose = vive_device_get_tracked_pose; 782 782 - d->base.get_view_pose = vive_device_get_view_pose; 783 764 d->base.get_view_poses = vive_device_get_view_poses; 784 765 d->base.destroy = vive_device_destroy; 785 766 d->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;

-13

src/xrt/drivers/wmr/wmr_hmd.c

reviewed

··· 981 981 } 982 982 983 983 static void 984 984 - wmr_hmd_get_view_pose(struct xrt_device *xdev, 985 985 - const struct xrt_vec3 *eye_relation, 986 986 - uint32_t view_index, 987 987 - struct xrt_pose *out_pose) 988 988 - { 989 989 - DRV_TRACE_MARKER(); 990 990 - 991 991 - (void)xdev; 992 992 - u_device_get_view_pose(eye_relation, view_index, out_pose); 993 993 - } 994 994 - 995 995 - static void 996 984 wmr_hmd_get_view_poses(struct xrt_device *xdev, 997 985 const struct xrt_vec3 *default_eye_relation, 998 986 uint64_t at_timestamp_ns, ··· 1245 1233 // Populate the base members. 1246 1234 wh->base.update_inputs = wmr_hmd_update_inputs; 1247 1235 wh->base.get_tracked_pose = wmr_hmd_get_tracked_pose; 1248 1248 - wh->base.get_view_pose = wmr_hmd_get_view_pose; 1249 1236 wh->base.get_view_poses = wmr_hmd_get_view_poses; 1250 1237 wh->base.destroy = wmr_hmd_destroy; 1251 1238 wh->base.name = XRT_DEVICE_GENERIC_HMD;

-47

src/xrt/include/xrt/xrt_device.h

reviewed

··· 347 347 * xrt_device::get_tracked_pose for that. 348 348 * 349 349 * @param[in] xdev The device. 350 350 - * @param[in] eye_relation The interpupillary relation as a 3D position. 351 351 - * Most simple stereo devices would just want to 352 352 - * set `out_pose->position.[x|y|z] = ipd.[x|y|z] 353 353 - * / 2.0f` and adjust for left vs right view. 354 354 - * Not to be confused with IPD that is absolute 355 355 - * distance, this is a full 3D translation 356 356 - * If a device has a more accurate/dynamic way of 357 357 - * knowing the eye relation, it may ignore this 358 358 - * input. 359 359 - * @param[in] view_index Index of view. 360 360 - * @param[out] out_pose Output pose. See eye_relation argument for 361 361 - * sample position. Be sure to also set 362 362 - * orientation: most likely identity 363 363 - * orientation unless you have canted screens. 364 364 - * (Caution: Even if you have eye tracking, you 365 365 - * won't use eye orientation here!) 366 366 - */ 367 367 - void (*get_view_pose)(struct xrt_device *xdev, 368 368 - const struct xrt_vec3 *eye_relation, 369 369 - uint32_t view_index, 370 370 - struct xrt_pose *out_pose); 371 371 - 372 372 - /*! 373 373 - * @brief Get the per-view pose in relation to the view space. 374 374 - * 375 375 - * On most device with coplanar displays, this just calls a helper to 376 376 - * process the provided eye relation, but this may also handle canted 377 377 - * displays as well as eye tracking. 378 378 - * 379 379 - * Does not do any device level tracking, use 380 380 - * xrt_device::get_tracked_pose for that. 381 381 - * 382 382 - * @param[in] xdev The device. 383 350 * @param[in] default_eye_relation 384 351 * The interpupillary relation as a 3D position. 385 352 * Most simple stereo devices would just want to ··· 463 430 xrt_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, union xrt_output_value *value) 464 431 { 465 432 xdev->set_output(xdev, name, value); 466 466 - } 467 467 - 468 468 - /*! 469 469 - * Helper function for @ref xrt_device::get_view_pose. 470 470 - * 471 471 - * @public @memberof xrt_device 472 472 - */ 473 473 - static inline void 474 474 - xrt_device_get_view_pose(struct xrt_device *xdev, 475 475 - const struct xrt_vec3 *eye_relation, 476 476 - uint32_t view_index, 477 477 - struct xrt_pose *out_pose) 478 478 - { 479 479 - xdev->get_view_pose(xdev, eye_relation, view_index, out_pose); 480 433 } 481 434 482 435 /*!

-11

src/xrt/ipc/client/ipc_client_device.c

reviewed

··· 120 120 } 121 121 122 122 static void 123 123 - ipc_client_device_get_view_pose(struct xrt_device *xdev, 124 124 - const struct xrt_vec3 *eye_relation, 125 125 - uint32_t view_index, 126 126 - struct xrt_pose *out_pose) 127 127 - { 128 128 - // Empty 129 129 - assert(false); 130 130 - } 131 131 - 132 132 - static void 133 123 ipc_client_device_get_view_poses(struct xrt_device *xdev, 134 124 const struct xrt_vec3 *default_eye_relation, 135 125 uint64_t at_timestamp_ns, ··· 170 160 icd->base.update_inputs = ipc_client_device_update_inputs; 171 161 icd->base.get_tracked_pose = ipc_client_device_get_tracked_pose; 172 162 icd->base.get_hand_tracking = ipc_client_device_get_hand_tracking; 173 173 - icd->base.get_view_pose = ipc_client_device_get_view_pose; 174 163 icd->base.get_view_poses = ipc_client_device_get_view_poses; 175 164 icd->base.set_output = ipc_client_device_set_output; 176 165 icd->base.destroy = ipc_client_device_destroy;

-15

src/xrt/ipc/client/ipc_client_hmd.c

reviewed

··· 105 105 } 106 106 107 107 static void 108 108 - ipc_client_hmd_get_view_pose(struct xrt_device *xdev, 109 109 - const struct xrt_vec3 *eye_relation, 110 110 - uint32_t view_index, 111 111 - struct xrt_pose *out_pose) 112 112 - { 113 113 - struct ipc_client_hmd *ich = ipc_client_hmd(xdev); 114 114 - 115 115 - xrt_result_t r = ipc_call_device_get_view_pose(ich->ipc_c, ich->device_id, eye_relation, view_index, out_pose); 116 116 - if (r != XRT_SUCCESS) { 117 117 - IPC_ERROR(ich->ipc_c, "Error calling view pose!"); 118 118 - } 119 119 - } 120 120 - 121 121 - static void 122 108 ipc_client_hmd_get_view_poses(struct xrt_device *xdev, 123 109 const struct xrt_vec3 *default_eye_relation, 124 110 uint64_t at_timestamp_ns, ··· 171 157 ich->device_id = device_id; 172 158 ich->base.update_inputs = ipc_client_hmd_update_inputs; 173 159 ich->base.get_tracked_pose = ipc_client_hmd_get_tracked_pose; 174 174 - ich->base.get_view_pose = ipc_client_hmd_get_view_pose; 175 160 ich->base.get_view_poses = ipc_client_hmd_get_view_poses; 176 161 ich->base.destroy = ipc_client_hmd_destroy; 177 162

-17

src/xrt/ipc/server/ipc_server_handler.c

reviewed

··· 955 955 } 956 956 957 957 xrt_result_t 958 958 - ipc_handle_device_get_view_pose(volatile struct ipc_client_state *ics, 959 959 - uint32_t id, 960 960 - const struct xrt_vec3 *eye_relation, 961 961 - uint32_t view_index, 962 962 - struct xrt_pose *out_pose) 963 963 - { 964 964 - // To make the code a bit more readable. 965 965 - uint32_t device_id = id; 966 966 - struct xrt_device *xdev = get_xdev(ics, device_id); 967 967 - 968 968 - // Get the pose. 969 969 - xrt_device_get_view_pose(xdev, eye_relation, view_index, out_pose); 970 970 - 971 971 - return XRT_SUCCESS; 972 972 - } 973 973 - 974 974 - xrt_result_t 975 958 ipc_handle_device_get_view_poses_2(volatile struct ipc_client_state *ics, 976 959 uint32_t id, 977 960 const struct xrt_vec3 *default_eye_relation,

-11

src/xrt/ipc/shared/proto.json

reviewed

··· 201 201 ] 202 202 }, 203 203 204 204 - "device_get_view_pose": { 205 205 - "in": [ 206 206 - {"name": "id", "type": "uint32_t"}, 207 207 - {"name": "eye_relation", "type": "const struct xrt_vec3"}, 208 208 - {"name": "view_index", "type": "uint32_t"} 209 209 - ], 210 210 - "out": [ 211 211 - {"name": "pose", "type": "struct xrt_pose"} 212 212 - ] 213 213 - }, 214 214 - 215 204 "device_get_view_poses_2": { 216 205 "in": [ 217 206 {"name": "id", "type": "uint32_t"},