matrixfurry.com / monado
The open source OpenXR runtime
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

d/all: Standardize use of get_view_poses helper

Jakob Bornecrantz 9149352c 1254e504

+69 -216
+1 -14
src/xrt/drivers/android/android_sensors.c
··· 185 185 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT); 186 186 } 187 187 188 - static void 189 - android_device_get_view_poses(struct xrt_device *xdev, 190 - const struct xrt_vec3 *default_eye_relation, 191 - uint64_t at_timestamp_ns, 192 - uint32_t view_count, 193 - struct xrt_space_relation *out_head_relation, 194 - struct xrt_fov *out_fovs, 195 - struct xrt_pose *out_poses) 196 - { 197 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 198 - out_poses); 199 - } 200 - 201 188 202 189 /* 203 190 * ··· 225 212 d->base.destroy = android_device_destroy; 226 213 d->base.update_inputs = u_device_noop_update_inputs; 227 214 d->base.get_tracked_pose = android_device_get_tracked_pose; 228 - d->base.get_view_poses = android_device_get_view_poses; 215 + d->base.get_view_poses = u_device_get_view_poses; 229 216 d->base.compute_distortion = android_device_compute_distortion; 230 217 d->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 231 218 d->base.device_type = XRT_DEVICE_TYPE_HMD;
+3 -14
src/xrt/drivers/euroc/euroc_device.c
··· 156 156 } 157 157 158 158 static void 159 - euroc_get_view_poses(struct xrt_device *xdev, 160 - const struct xrt_vec3 *default_eye_relation, 161 - uint64_t at_timestamp_ns, 162 - uint32_t view_count, 163 - struct xrt_space_relation *out_head_relation, 164 - struct xrt_fov *out_fovs, 165 - struct xrt_pose *out_poses) 166 - { 167 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 168 - out_poses); 169 - } 170 - 171 - static void 172 159 euroc_device_destroy(struct xrt_device *xdev) 173 160 { 174 161 struct euroc_device *ed = euroc_device(xdev); ··· 247 234 xd->get_tracked_pose = euroc_device_get_tracked_pose; 248 235 xd->destroy = euroc_device_destroy; 249 236 if (is_hmd) { 250 - xd->get_view_poses = euroc_get_view_poses; 237 + xd->get_view_poses = u_device_get_view_poses; 238 + } else { 239 + xd->get_view_poses = u_device_ni_get_view_poses; 251 240 } 252 241 253 242 u_var_add_root(ed, dev_name, false);
+1 -14
src/xrt/drivers/hdk/hdk_device.cpp
··· 250 250 hd->quat.w, hd->ang_vel_quat.x, hd->ang_vel_quat.y, hd->ang_vel_quat.z); 251 251 } 252 252 253 - static void 254 - hdk_device_get_view_poses(struct xrt_device *xdev, 255 - const struct xrt_vec3 *default_eye_relation, 256 - uint64_t at_timestamp_ns, 257 - uint32_t view_count, 258 - struct xrt_space_relation *out_head_relation, 259 - struct xrt_fov *out_fovs, 260 - struct xrt_pose *out_poses) 261 - { 262 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 263 - out_poses); 264 - } 265 - 266 253 static void * 267 254 hdk_device_run_thread(void *ptr) 268 255 { ··· 305 292 306 293 hd->base.update_inputs = u_device_noop_update_inputs; 307 294 hd->base.get_tracked_pose = hdk_device_get_tracked_pose; 308 - hd->base.get_view_poses = hdk_device_get_view_poses; 295 + hd->base.get_view_poses = u_device_get_view_poses; 309 296 hd->base.destroy = hdk_device_destroy; 310 297 hd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 311 298 hd->base.name = XRT_DEVICE_GENERIC_HMD;
+1 -14
src/xrt/drivers/illixr/illixr_device.cpp
··· 124 124 XRT_SPACE_RELATION_POSITION_VALID_BIT | XRT_SPACE_RELATION_POSITION_TRACKED_BIT); 125 125 } 126 126 127 - static void 128 - illixr_hmd_get_view_poses(struct xrt_device *xdev, 129 - const struct xrt_vec3 *default_eye_relation, 130 - uint64_t at_timestamp_ns, 131 - uint32_t view_count, 132 - struct xrt_space_relation *out_head_relation, 133 - struct xrt_fov *out_fovs, 134 - struct xrt_pose *out_poses) 135 - { 136 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 137 - out_poses); 138 - } 139 - 140 127 std::vector<std::string> 141 128 split(const std::string &s, char delimiter) 142 129 { ··· 169 156 dh = U_DEVICE_ALLOCATE(struct illixr_hmd, flags, 1, 0); 170 157 dh->base.update_inputs = u_device_noop_update_inputs; 171 158 dh->base.get_tracked_pose = illixr_hmd_get_tracked_pose; 172 - dh->base.get_view_poses = illixr_hmd_get_view_poses; 159 + dh->base.get_view_poses = u_device_get_view_poses; 173 160 dh->base.destroy = illixr_hmd_destroy; 174 161 dh->base.name = XRT_DEVICE_GENERIC_HMD; 175 162 dh->base.device_type = XRT_DEVICE_TYPE_HMD;
+8 -2
src/xrt/drivers/north_star/ns_hmd.c
··· 397 397 NS_DEBUG(ns, "Called!"); 398 398 399 399 // Use this to take care of most stuff, then fix up below. 400 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 401 - out_poses); 400 + u_device_get_view_poses( // 401 + xdev, // 402 + default_eye_relation, // 403 + at_timestamp_ns, // 404 + view_count, // 405 + out_head_relation, // 406 + out_fovs, // 407 + out_poses); // 402 408 403 409 // Fix fix. 404 410 for (uint32_t i = 0; i < view_count && i < ARRAY_SIZE(ns->config.head_pose_to_eye); i++) {
+1 -14
src/xrt/drivers/nreal_air/na_hmd.c
··· 1071 1071 } 1072 1072 1073 1073 static void 1074 - na_hmd_get_view_poses(struct xrt_device *xdev, 1075 - const struct xrt_vec3 *default_eye_relation, 1076 - uint64_t at_timestamp_ns, 1077 - uint32_t view_count, 1078 - struct xrt_space_relation *out_head_relation, 1079 - struct xrt_fov *out_fovs, 1080 - struct xrt_pose *out_poses) 1081 - { 1082 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 1083 - out_poses); 1084 - } 1085 - 1086 - static void 1087 1074 na_hmd_destroy(struct xrt_device *xdev) 1088 1075 { 1089 1076 struct na_hmd *hmd = na_hmd(xdev); ··· 1117 1104 hmd->log_level = log_level; 1118 1105 hmd->base.update_inputs = na_hmd_update_inputs; 1119 1106 hmd->base.get_tracked_pose = na_hmd_get_tracked_pose; 1120 - hmd->base.get_view_poses = na_hmd_get_view_poses; 1107 + hmd->base.get_view_poses = u_device_get_view_poses; 1121 1108 hmd->base.compute_distortion = na_hmd_compute_distortion; 1122 1109 hmd->base.destroy = na_hmd_destroy; 1123 1110 hmd->base.name = XRT_DEVICE_GENERIC_HMD;
+2 -14
src/xrt/drivers/ohmd/oh_device.c
··· 449 449 ohd->last_relation = *out_relation; 450 450 } 451 451 452 - static void 453 - oh_device_get_view_poses(struct xrt_device *xdev, 454 - const struct xrt_vec3 *default_eye_relation, 455 - uint64_t at_timestamp_ns, 456 - uint32_t view_count, 457 - struct xrt_space_relation *out_head_relation, 458 - struct xrt_fov *out_fovs, 459 - struct xrt_pose *out_poses) 460 - { 461 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 462 - out_poses); 463 - } 464 452 465 453 struct display_info 466 454 { ··· 741 729 struct oh_device *ohd = U_DEVICE_ALLOCATE(struct oh_device, flags, 1, 0); 742 730 ohd->base.update_inputs = oh_device_update_inputs; 743 731 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 744 - ohd->base.get_view_poses = oh_device_get_view_poses; 732 + ohd->base.get_view_poses = u_device_get_view_poses; 745 733 ohd->base.destroy = oh_device_destroy; 746 734 ohd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 747 735 ohd->base.name = XRT_DEVICE_GENERIC_HMD; ··· 1057 1045 ohd->base.update_inputs = oh_device_update_inputs; 1058 1046 ohd->base.set_output = oh_device_set_output; 1059 1047 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 1060 - ohd->base.get_view_poses = oh_device_get_view_poses; 1048 + ohd->base.get_view_poses = u_device_ni_get_view_poses; 1061 1049 ohd->base.destroy = oh_device_destroy; 1062 1050 if (oculus_touch) { 1063 1051 ohd->ohmd_device_type = OPENHMD_OCULUS_RIFT_CONTROLLER;
+1 -14
src/xrt/drivers/psvr/psvr_device.c
··· 994 994 } 995 995 996 996 static void 997 - psvr_device_get_view_poses(struct xrt_device *xdev, 998 - const struct xrt_vec3 *default_eye_relation, 999 - uint64_t at_timestamp_ns, 1000 - uint32_t view_count, 1001 - struct xrt_space_relation *out_head_relation, 1002 - struct xrt_fov *out_fovs, 1003 - struct xrt_pose *out_poses) 1004 - { 1005 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 1006 - out_poses); 1007 - } 1008 - 1009 - static void 1010 997 psvr_device_destroy(struct xrt_device *xdev) 1011 998 { 1012 999 struct psvr_device *psvr = psvr_device(xdev); ··· 1044 1031 psvr->log_level = log_level; 1045 1032 psvr->base.update_inputs = psvr_device_update_inputs; 1046 1033 psvr->base.get_tracked_pose = psvr_device_get_tracked_pose; 1047 - psvr->base.get_view_poses = psvr_device_get_view_poses; 1034 + psvr->base.get_view_poses = u_device_get_view_poses; 1048 1035 psvr->base.compute_distortion = psvr_compute_distortion; 1049 1036 psvr->base.destroy = psvr_device_destroy; 1050 1037 psvr->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
+1 -14
src/xrt/drivers/qwerty/qwerty_device.c
··· 205 205 } 206 206 207 207 static void 208 - qwerty_get_view_poses(struct xrt_device *xdev, 209 - const struct xrt_vec3 *default_eye_relation, 210 - uint64_t at_timestamp_ns, 211 - uint32_t view_count, 212 - struct xrt_space_relation *out_head_relation, 213 - struct xrt_fov *out_fovs, 214 - struct xrt_pose *out_poses) 215 - { 216 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 217 - out_poses); 218 - } 219 - 220 - static void 221 208 qwerty_destroy(struct xrt_device *xd) 222 209 { 223 210 // Note: do not destroy a single device of a qwerty system or its var tracking ··· 274 261 275 262 xd->update_inputs = qwerty_update_inputs; 276 263 xd->get_tracked_pose = qwerty_get_tracked_pose; 277 - xd->get_view_poses = qwerty_get_view_poses; 264 + xd->get_view_poses = u_device_get_view_poses; 278 265 xd->destroy = qwerty_destroy; 279 266 u_distortion_mesh_set_none(xd); // Fill in xd->compute_distortion() 280 267
+1 -14
src/xrt/drivers/rift_s/rift_s_controller.c
··· 574 574 } 575 575 576 576 static void 577 - rift_s_controller_get_view_poses(struct xrt_device *xdev, 578 - const struct xrt_vec3 *default_eye_relation, 579 - uint64_t at_timestamp_ns, 580 - uint32_t view_count, 581 - struct xrt_space_relation *out_head_relation, 582 - struct xrt_fov *out_fovs, 583 - struct xrt_pose *out_poses) 584 - { 585 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 586 - out_poses); 587 - } 588 - 589 - static void 590 577 rift_s_controller_destroy(struct xrt_device *xdev) 591 578 { 592 579 struct rift_s_controller *ctrl = (struct rift_s_controller *)(xdev); ··· 626 613 ctrl->base.update_inputs = rift_s_controller_update_inputs; 627 614 ctrl->base.set_output = rift_s_controller_set_output; 628 615 ctrl->base.get_tracked_pose = rift_s_controller_get_tracked_pose; 629 - ctrl->base.get_view_poses = rift_s_controller_get_view_poses; 616 + ctrl->base.get_view_poses = u_device_get_view_poses; 630 617 ctrl->base.destroy = rift_s_controller_destroy; 631 618 ctrl->base.name = XRT_DEVICE_TOUCH_CONTROLLER; 632 619 ctrl->base.device_type = device_type;
+1 -14
src/xrt/drivers/rift_s/rift_s_hmd.c
··· 62 62 rift_s_tracker_get_tracked_pose(hmd->tracker, RIFT_S_TRACKER_POSE_DEVICE, at_timestamp_ns, out_relation); 63 63 } 64 64 65 - static void 66 - rift_s_get_view_poses(struct xrt_device *xdev, 67 - const struct xrt_vec3 *default_eye_relation, 68 - uint64_t at_timestamp_ns, 69 - uint32_t view_count, 70 - struct xrt_space_relation *out_head_relation, 71 - struct xrt_fov *out_fovs, 72 - struct xrt_pose *out_poses) 73 - { 74 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 75 - out_poses); 76 - } 77 - 78 65 void 79 66 rift_s_hmd_handle_report(struct rift_s_hmd *hmd, timepoint_ns local_ts, rift_s_hmd_report_t *report) 80 67 { ··· 227 214 228 215 hmd->base.update_inputs = u_device_noop_update_inputs; 229 216 hmd->base.get_tracked_pose = rift_s_get_tracked_pose; 230 - hmd->base.get_view_poses = rift_s_get_view_poses; 217 + hmd->base.get_view_poses = u_device_get_view_poses; 231 218 hmd->base.destroy = rift_s_hmd_destroy; 232 219 hmd->base.name = XRT_DEVICE_GENERIC_HMD; 233 220 hmd->base.device_type = XRT_DEVICE_TYPE_HMD;
+1 -14
src/xrt/drivers/rokid/rokid_hmd.c
··· 447 447 os_mutex_unlock(&rokid->fusion.mutex); 448 448 } 449 449 450 - static void 451 - rokid_hmd_get_view_poses(struct xrt_device *xdev, 452 - const struct xrt_vec3 *default_eye_relation, 453 - uint64_t at_timestamp_ns, 454 - uint32_t view_count, 455 - struct xrt_space_relation *out_head_relation, 456 - struct xrt_fov *out_fovs, 457 - struct xrt_pose *out_poses) 458 - { 459 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 460 - out_poses); 461 - } 462 - 463 450 static struct xrt_device * 464 451 rokid_hmd_create(struct xrt_prober_device *prober_device) 465 452 { ··· 494 481 495 482 rokid->base.update_inputs = u_device_noop_update_inputs; 496 483 rokid->base.get_tracked_pose = rokid_hmd_get_tracked_pose; 497 - rokid->base.get_view_poses = rokid_hmd_get_view_poses; 484 + rokid->base.get_view_poses = u_device_get_view_poses; 498 485 rokid->base.destroy = rokid_hmd_destroy; 499 486 500 487 // Setup input.
+12 -2
src/xrt/drivers/sample/sample_hmd.c
··· 110 110 struct xrt_fov *out_fovs, 111 111 struct xrt_pose *out_poses) 112 112 { 113 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 114 - out_poses); 113 + /* 114 + * For HMDs you can call this function or directly set 115 + * the `get_view_poses` function on the device to it. 116 + */ 117 + u_device_get_view_poses( // 118 + xdev, // 119 + default_eye_relation, // 120 + at_timestamp_ns, // 121 + view_count, // 122 + out_head_relation, // 123 + out_fovs, // 124 + out_poses); // 115 125 } 116 126 117 127 bool
+8 -4
src/xrt/drivers/simula/svr_hmd.c
··· 108 108 //!@todo: default_eye_relation inherits from the env var OXR_DEBUG_IPD_MM / oxr_session.c 109 109 // probably needs a lot more attention 110 110 111 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 112 - out_poses); 113 - 114 - 111 + u_device_get_view_poses( // 112 + xdev, // 113 + default_eye_relation, // 114 + at_timestamp_ns, // 115 + view_count, // 116 + out_head_relation, // 117 + out_fovs, // 118 + out_poses); // 115 119 116 120 //!@todo you may need to invert this - I can't test locally 117 121 float turn_vals[2] = {5.0, -5.0};
+1 -14
src/xrt/drivers/simulated/simulated_hmd.c
··· 143 143 XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT); 144 144 } 145 145 146 - static void 147 - simulated_hmd_get_view_poses(struct xrt_device *xdev, 148 - const struct xrt_vec3 *default_eye_relation, 149 - uint64_t at_timestamp_ns, 150 - uint32_t view_count, 151 - struct xrt_space_relation *out_head_relation, 152 - struct xrt_fov *out_fovs, 153 - struct xrt_pose *out_poses) 154 - { 155 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 156 - out_poses); 157 - } 158 - 159 146 static xrt_result_t 160 147 simulated_ref_space_usage(struct xrt_device *xdev, 161 148 enum xrt_reference_space_type type, ··· 205 192 struct simulated_hmd *dh = U_DEVICE_ALLOCATE(struct simulated_hmd, flags, 1, 0); 206 193 dh->base.update_inputs = u_device_noop_update_inputs; 207 194 dh->base.get_tracked_pose = simulated_hmd_get_tracked_pose; 208 - dh->base.get_view_poses = simulated_hmd_get_view_poses; 195 + dh->base.get_view_poses = u_device_get_view_poses; 209 196 dh->base.ref_space_usage = simulated_ref_space_usage; 210 197 dh->base.destroy = simulated_hmd_destroy; 211 198 dh->base.name = XRT_DEVICE_GENERIC_HMD;
+8 -2
src/xrt/drivers/steamvr_lh/device.cpp
··· 521 521 struct xrt_vec3 eye_relation = *default_eye_relation; 522 522 eye_relation.x = ipd; 523 523 524 - u_device_get_view_poses(this, &eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 525 - out_poses); 524 + u_device_get_view_poses( // 525 + this, // 526 + &eye_relation, // 527 + at_timestamp_ns, // 528 + view_count, // 529 + out_head_relation, // 530 + out_fovs, // 531 + out_poses); // 526 532 527 533 out_poses[0].orientation = this->eye[0].orientation; 528 534 out_poses[0].position.z = this->eye[0].position.z;
+8 -2
src/xrt/drivers/survive/survive_driver.c
··· 528 528 eye_relation.x = survive->hmd.ipd; 529 529 } 530 530 531 - u_device_get_view_poses(xdev, &eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 532 - out_poses); 531 + u_device_get_view_poses( // 532 + xdev, // 533 + &eye_relation, // 534 + at_timestamp_ns, // 535 + view_count, // 536 + out_head_relation, // 537 + out_fovs, // 538 + out_poses); // 533 539 534 540 // This is for the Index' canted displays, on the Vive [Pro] they are identity. 535 541 for (uint32_t i = 0; i < view_count && i < ARRAY_SIZE(survive->hmd.config.display.rot); i++) {
+8 -2
src/xrt/drivers/vive/vive_device.c
··· 205 205 // Only supports two views. 206 206 assert(view_count <= 2); 207 207 208 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 209 - out_poses); 208 + u_device_get_view_poses( // 209 + xdev, // 210 + default_eye_relation, // 211 + at_timestamp_ns, // 212 + view_count, // 213 + out_head_relation, // 214 + out_fovs, // 215 + out_poses); // 210 216 211 217 // This is for the Index' canted displays, on the Vive [Pro] they are identity. 212 218 struct vive_device *d = vive_device(xdev);
+1 -14
src/xrt/drivers/wmr/wmr_hmd.c
··· 1178 1178 } 1179 1179 1180 1180 static void 1181 - wmr_hmd_get_view_poses(struct xrt_device *xdev, 1182 - const struct xrt_vec3 *default_eye_relation, 1183 - uint64_t at_timestamp_ns, 1184 - uint32_t view_count, 1185 - struct xrt_space_relation *out_head_relation, 1186 - struct xrt_fov *out_fovs, 1187 - struct xrt_pose *out_poses) 1188 - { 1189 - u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 1190 - out_poses); 1191 - } 1192 - 1193 - static void 1194 1181 wmr_hmd_destroy(struct xrt_device *xdev) 1195 1182 { 1196 1183 DRV_TRACE_MARKER(); ··· 1889 1876 // Populate the base members. 1890 1877 wh->base.update_inputs = u_device_noop_update_inputs; 1891 1878 wh->base.get_tracked_pose = wmr_hmd_get_tracked_pose; 1892 - wh->base.get_view_poses = wmr_hmd_get_view_poses; 1879 + wh->base.get_view_poses = u_device_get_view_poses; 1893 1880 wh->base.destroy = wmr_hmd_destroy; 1894 1881 wh->base.name = XRT_DEVICE_GENERIC_HMD; 1895 1882 wh->base.device_type = XRT_DEVICE_TYPE_HMD;
+1 -20
src/xrt/targets/sdl_test/sdl_device.c
··· 40 40 } 41 41 42 42 static void 43 - sdl_hmd_get_view_poses(struct xrt_device *xdev, 44 - const struct xrt_vec3 *default_eye_relation, 45 - uint64_t at_timestamp_ns, 46 - uint32_t view_count, 47 - struct xrt_space_relation *out_head_relation, 48 - struct xrt_fov *out_fovs, 49 - struct xrt_pose *out_poses) 50 - { 51 - u_device_get_view_poses( // 52 - xdev, // 53 - default_eye_relation, // 54 - at_timestamp_ns, // 55 - view_count, // 56 - out_head_relation, // 57 - out_fovs, // 58 - out_poses); // 59 - } 60 - 61 - static void 62 43 sdl_hmd_destroy(struct xrt_device *xdev) 63 44 { 64 45 struct sdl_program *sp = from_xdev(xdev); ··· 109 90 // Function pointers. 110 91 xdev->update_inputs = u_device_noop_update_inputs; 111 92 xdev->get_tracked_pose = sdl_hmd_get_tracked_pose; 112 - xdev->get_view_poses = sdl_hmd_get_view_poses; 93 + xdev->get_view_poses = u_device_get_view_poses; 113 94 xdev->destroy = sdl_hmd_destroy; 114 95 115 96 // Minimum needed stuff.