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

Configure Feed

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

drivers: Implement xrt_device::get_view_poses

Co-authored-by: Christoph Haag <christoph.haag@collabora.com>

Jakob Bornecrantz 0511b319 223aa515

+271 -2
+15
src/xrt/drivers/android/android_sensors.c
··· 178 178 u_device_get_view_pose(eye_relation, view_index, out_pose); 179 179 } 180 180 181 + static void 182 + android_device_get_view_poses(struct xrt_device *xdev, 183 + const struct xrt_vec3 *default_eye_relation, 184 + uint64_t at_timestamp_ns, 185 + uint32_t view_count, 186 + struct xrt_space_relation *out_head_relation, 187 + struct xrt_fov *out_fovs, 188 + struct xrt_pose *out_poses) 189 + { 190 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 191 + out_poses); 192 + } 193 + 194 + 181 195 /* 182 196 * 183 197 * Prober functions. ··· 204 218 d->base.update_inputs = android_device_update_inputs; 205 219 d->base.get_tracked_pose = android_device_get_tracked_pose; 206 220 d->base.get_view_pose = android_device_get_view_pose; 221 + d->base.get_view_poses = android_device_get_view_poses; 207 222 d->base.compute_distortion = android_device_compute_distortion; 208 223 d->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 209 224 d->base.device_type = XRT_DEVICE_TYPE_HMD;
+14
src/xrt/drivers/dummy/dummy_hmd.c
··· 153 153 u_device_get_view_pose(eye_relation, view_index, out_pose); 154 154 } 155 155 156 + static void 157 + dummy_hmd_get_view_poses(struct xrt_device *xdev, 158 + const struct xrt_vec3 *default_eye_relation, 159 + uint64_t at_timestamp_ns, 160 + uint32_t view_count, 161 + struct xrt_space_relation *out_head_relation, 162 + struct xrt_fov *out_fovs, 163 + struct xrt_pose *out_poses) 164 + { 165 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 166 + out_poses); 167 + } 168 + 156 169 struct xrt_device * 157 170 dummy_hmd_create(void) 158 171 { ··· 162 175 dh->base.update_inputs = dummy_hmd_update_inputs; 163 176 dh->base.get_tracked_pose = dummy_hmd_get_tracked_pose; 164 177 dh->base.get_view_pose = dummy_hmd_get_view_pose; 178 + dh->base.get_view_poses = dummy_hmd_get_view_poses; 165 179 dh->base.destroy = dummy_hmd_destroy; 166 180 dh->base.name = XRT_DEVICE_GENERIC_HMD; 167 181 dh->base.device_type = XRT_DEVICE_TYPE_HMD;
+14
src/xrt/drivers/euroc/euroc_device.c
··· 170 170 } 171 171 172 172 static void 173 + euroc_get_view_poses(struct xrt_device *xdev, 174 + const struct xrt_vec3 *default_eye_relation, 175 + uint64_t at_timestamp_ns, 176 + uint32_t view_count, 177 + struct xrt_space_relation *out_head_relation, 178 + struct xrt_fov *out_fovs, 179 + struct xrt_pose *out_poses) 180 + { 181 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 182 + out_poses); 183 + } 184 + 185 + static void 173 186 euroc_device_destroy(struct xrt_device *xdev) 174 187 { 175 188 struct euroc_device *ed = euroc_device(xdev); ··· 249 262 xd->destroy = euroc_device_destroy; 250 263 if (is_hmd) { 251 264 xd->get_view_pose = euroc_get_view_pose; 265 + xd->get_view_poses = euroc_get_view_poses; 252 266 } 253 267 254 268 u_var_add_root(ed, dev_name, false);
+14
src/xrt/drivers/hdk/hdk_device.cpp
··· 263 263 u_device_get_view_pose(eye_relation, view_index, out_pose); 264 264 } 265 265 266 + static void 267 + hdk_device_get_view_poses(struct xrt_device *xdev, 268 + const struct xrt_vec3 *default_eye_relation, 269 + uint64_t at_timestamp_ns, 270 + uint32_t view_count, 271 + struct xrt_space_relation *out_head_relation, 272 + struct xrt_fov *out_fovs, 273 + struct xrt_pose *out_poses) 274 + { 275 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 276 + out_poses); 277 + } 278 + 266 279 static void * 267 280 hdk_device_run_thread(void *ptr) 268 281 { ··· 306 319 hd->base.update_inputs = hdk_device_update_inputs; 307 320 hd->base.get_tracked_pose = hdk_device_get_tracked_pose; 308 321 hd->base.get_view_pose = hdk_device_get_view_pose; 322 + hd->base.get_view_poses = hdk_device_get_view_poses; 309 323 hd->base.destroy = hdk_device_destroy; 310 324 hd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 311 325 hd->base.name = XRT_DEVICE_GENERIC_HMD;
+14
src/xrt/drivers/illixr/illixr_device.cpp
··· 140 140 u_device_get_view_pose(eye_relation, view_index, out_pose); 141 141 } 142 142 143 + static void 144 + illixr_hmd_get_view_poses(struct xrt_device *xdev, 145 + const struct xrt_vec3 *default_eye_relation, 146 + uint64_t at_timestamp_ns, 147 + uint32_t view_count, 148 + struct xrt_space_relation *out_head_relation, 149 + struct xrt_fov *out_fovs, 150 + struct xrt_pose *out_poses) 151 + { 152 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 153 + out_poses); 154 + } 155 + 143 156 std::vector<std::string> 144 157 split(const std::string &s, char delimiter) 145 158 { ··· 173 186 dh->base.update_inputs = illixr_hmd_update_inputs; 174 187 dh->base.get_tracked_pose = illixr_hmd_get_tracked_pose; 175 188 dh->base.get_view_pose = illixr_hmd_get_view_pose; 189 + dh->base.get_view_poses = illixr_hmd_get_view_poses; 176 190 dh->base.destroy = illixr_hmd_destroy; 177 191 dh->base.name = XRT_DEVICE_GENERIC_HMD; 178 192 dh->base.device_type = XRT_DEVICE_TYPE_HMD;
+16
src/xrt/drivers/multi_wrapper/multi.c
··· 193 193 xrt_device_get_view_pose(target, eye_relation, view_index, out_pose); 194 194 } 195 195 196 + static void 197 + get_view_poses(struct xrt_device *xdev, 198 + const struct xrt_vec3 *default_eye_relation, 199 + uint64_t at_timestamp_ns, 200 + uint32_t view_count, 201 + struct xrt_space_relation *out_head_relation, 202 + struct xrt_fov *out_fovs, 203 + struct xrt_pose *out_poses) 204 + { 205 + struct multi_device *d = (struct multi_device *)xdev; 206 + struct xrt_device *target = d->tracking_override.target; 207 + xrt_device_get_view_poses(target, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, 208 + out_fovs, out_poses); 209 + } 210 + 196 211 static bool 197 212 compute_distortion(struct xrt_device *xdev, int view, float u, float v, struct xrt_uv_triplet *result) 198 213 { ··· 253 268 d->base.update_inputs = update_inputs; 254 269 d->base.compute_distortion = compute_distortion; 255 270 d->base.get_view_pose = get_view_pose; 271 + d->base.get_view_poses = get_view_poses; 256 272 257 273 return &d->base; 258 274 }
+21 -2
src/xrt/drivers/north_star/ns_hmd.c
··· 464 464 *out_pose = ns->head_pose_to_eye[view_index]; 465 465 } 466 466 467 + static void 468 + ns_hmd_get_view_poses(struct xrt_device *xdev, 469 + const struct xrt_vec3 *default_eye_relation, 470 + uint64_t at_timestamp_ns, 471 + uint32_t view_count, 472 + struct xrt_space_relation *out_head_relation, 473 + struct xrt_fov *out_fovs, 474 + struct xrt_pose *out_poses) 475 + { 476 + // Use this to take care of most stuff, then fix up below. 477 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 478 + out_poses); 479 + 480 + // Fix fix. 481 + struct ns_hmd *ns = ns_hmd(xdev); 482 + for (uint32_t i = 0; i < view_count && i < ARRAY_SIZE(ns->head_pose_to_eye); i++) { 483 + out_poses[i] = ns->head_pose_to_eye[i]; 484 + } 485 + } 486 + 467 487 static bool 468 488 ns_config_load(struct ns_hmd *ns, const char *config_path) 469 489 { ··· 568 588 ns->base.update_inputs = ns_hmd_update_inputs; 569 589 ns->base.get_tracked_pose = ns_hmd_get_tracked_pose; 570 590 ns->base.get_view_pose = ns_hmd_get_view_pose; 591 + ns->base.get_view_poses = ns_hmd_get_view_poses; 571 592 ns->base.destroy = ns_hmd_destroy; 572 593 ns->base.name = XRT_DEVICE_GENERIC_HMD; 573 594 math_pose_identity(&ns->no_tracker_relation.pose); ··· 601 622 602 623 ns->base.hmd->distortion.models = XRT_DISTORTION_MODEL_COMPUTE; 603 624 ns->base.hmd->distortion.preferred = XRT_DISTORTION_MODEL_COMPUTE; 604 - 605 - ns->base.get_view_pose = ns_hmd_get_view_pose; 606 625 607 626 // Setup variable tracker. 608 627 u_var_add_root(ns, "North Star", true);
+15
src/xrt/drivers/ohmd/oh_device.c
··· 437 437 u_device_get_view_pose(eye_relation, view_index, out_pose); 438 438 } 439 439 440 + static void 441 + oh_device_get_view_poses(struct xrt_device *xdev, 442 + const struct xrt_vec3 *default_eye_relation, 443 + uint64_t at_timestamp_ns, 444 + uint32_t view_count, 445 + struct xrt_space_relation *out_head_relation, 446 + struct xrt_fov *out_fovs, 447 + struct xrt_pose *out_poses) 448 + { 449 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 450 + out_poses); 451 + } 452 + 440 453 struct display_info 441 454 { 442 455 float w_meters; ··· 717 730 ohd->base.update_inputs = oh_device_update_inputs; 718 731 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 719 732 ohd->base.get_view_pose = oh_device_get_view_pose; 733 + ohd->base.get_view_poses = oh_device_get_view_poses; 720 734 ohd->base.destroy = oh_device_destroy; 721 735 ohd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 722 736 ohd->base.name = XRT_DEVICE_GENERIC_HMD; ··· 1033 1047 ohd->base.set_output = oh_device_set_output; 1034 1048 ohd->base.get_tracked_pose = oh_device_get_tracked_pose; 1035 1049 ohd->base.get_view_pose = oh_device_get_view_pose; 1050 + ohd->base.get_view_poses = oh_device_get_view_poses; 1036 1051 ohd->base.destroy = oh_device_destroy; 1037 1052 if (oculus_touch) { 1038 1053 ohd->ohmd_device_type = OPENHMD_OCULUS_RIFT_CONTROLLER;
+14
src/xrt/drivers/psvr/psvr_device.c
··· 938 938 } 939 939 940 940 static void 941 + psvr_device_get_view_poses(struct xrt_device *xdev, 942 + const struct xrt_vec3 *default_eye_relation, 943 + uint64_t at_timestamp_ns, 944 + uint32_t view_count, 945 + struct xrt_space_relation *out_head_relation, 946 + struct xrt_fov *out_fovs, 947 + struct xrt_pose *out_poses) 948 + { 949 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 950 + out_poses); 951 + } 952 + 953 + static void 941 954 psvr_device_destroy(struct xrt_device *xdev) 942 955 { 943 956 struct psvr_device *psvr = psvr_device(xdev); ··· 976 989 psvr->base.update_inputs = psvr_device_update_inputs; 977 990 psvr->base.get_tracked_pose = psvr_device_get_tracked_pose; 978 991 psvr->base.get_view_pose = psvr_device_get_view_pose; 992 + psvr->base.get_view_poses = psvr_device_get_view_poses; 979 993 psvr->base.compute_distortion = psvr_compute_distortion; 980 994 psvr->base.destroy = psvr_device_destroy; 981 995 psvr->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
+14
src/xrt/drivers/qwerty/qwerty_device.c
··· 214 214 } 215 215 216 216 static void 217 + qwerty_get_view_poses(struct xrt_device *xdev, 218 + const struct xrt_vec3 *default_eye_relation, 219 + uint64_t at_timestamp_ns, 220 + uint32_t view_count, 221 + struct xrt_space_relation *out_head_relation, 222 + struct xrt_fov *out_fovs, 223 + struct xrt_pose *out_poses) 224 + { 225 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 226 + out_poses); 227 + } 228 + 229 + static void 217 230 qwerty_destroy(struct xrt_device *xd) 218 231 { 219 232 // Note: do not destroy a single device of a qwerty system or its var tracking ··· 270 283 xd->update_inputs = qwerty_update_inputs; 271 284 xd->get_tracked_pose = qwerty_get_tracked_pose; 272 285 xd->get_view_pose = qwerty_get_view_pose; 286 + xd->get_view_poses = qwerty_get_view_poses; 273 287 xd->destroy = qwerty_destroy; 274 288 u_distortion_mesh_set_none(xd); // Fill in xd->compute_distortion() 275 289
+13
src/xrt/drivers/realsense/rs_ddev.c
··· 421 421 } 422 422 423 423 static void 424 + rs_ddev_get_view_poses(struct xrt_device *xdev, 425 + const struct xrt_vec3 *default_eye_relation, 426 + uint64_t at_timestamp_ns, 427 + uint32_t view_count, 428 + struct xrt_space_relation *out_head_relation, 429 + struct xrt_fov *out_fovs, 430 + struct xrt_pose *out_poses) 431 + { 432 + assert(false); 433 + } 434 + 435 + static void 424 436 rs_ddev_destroy(struct xrt_device *xdev) 425 437 { 426 438 struct rs_ddev *rs = rs_ddev(xdev); ··· 466 478 rs->base.update_inputs = rs_ddev_update_inputs; 467 479 rs->base.get_tracked_pose = rs_ddev_get_tracked_pose; 468 480 rs->base.get_view_pose = rs_ddev_get_view_pose; 481 + rs->base.get_view_poses = rs_ddev_get_view_poses; 469 482 rs->base.destroy = rs_ddev_destroy; 470 483 rs->base.name = XRT_DEVICE_REALSENSE; 471 484 rs->base.tracking_origin->type = XRT_TRACKING_TYPE_EXTERNAL_SLAM;
+13
src/xrt/drivers/remote/r_device.c
··· 162 162 } 163 163 164 164 static void 165 + r_device_get_view_poses(struct xrt_device *xdev, 166 + const struct xrt_vec3 *default_eye_relation, 167 + uint64_t at_timestamp_ns, 168 + uint32_t view_count, 169 + struct xrt_space_relation *out_head_relation, 170 + struct xrt_fov *out_fovs, 171 + struct xrt_pose *out_poses) 172 + { 173 + assert(false); 174 + } 175 + 176 + static void 165 177 r_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, union xrt_output_value *value) 166 178 { 167 179 struct r_device *rd = r_device(xdev); ··· 186 198 rd->base.get_tracked_pose = r_device_get_tracked_pose; 187 199 rd->base.get_hand_tracking = r_device_get_hand_tracking; 188 200 rd->base.get_view_pose = r_device_get_view_pose; 201 + rd->base.get_view_poses = r_device_get_view_poses; 189 202 rd->base.set_output = r_device_set_output; 190 203 rd->base.destroy = r_device_destroy; 191 204 rd->base.tracking_origin = &r->base;
+14
src/xrt/drivers/remote/r_hmd.c
··· 95 95 } 96 96 97 97 static void 98 + r_hmd_get_view_poses(struct xrt_device *xdev, 99 + const struct xrt_vec3 *default_eye_relation, 100 + uint64_t at_timestamp_ns, 101 + uint32_t view_count, 102 + struct xrt_space_relation *out_head_relation, 103 + struct xrt_fov *out_fovs, 104 + struct xrt_pose *out_poses) 105 + { 106 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 107 + out_poses); 108 + } 109 + 110 + static void 98 111 r_hmd_set_output(struct xrt_device *xdev, enum xrt_output_name name, union xrt_output_value *value) 99 112 { 100 113 // Empty ··· 118 131 rh->base.get_tracked_pose = r_hmd_get_tracked_pose; 119 132 rh->base.get_hand_tracking = r_hmd_get_hand_tracking; 120 133 rh->base.get_view_pose = r_hmd_get_view_pose; 134 + rh->base.get_view_poses = r_hmd_get_view_poses; 121 135 rh->base.set_output = r_hmd_set_output; 122 136 rh->base.destroy = r_hmd_destroy; 123 137 rh->base.tracking_origin = &r->base;
+14
src/xrt/drivers/sample/sample_hmd.c
··· 113 113 u_device_get_view_pose(eye_relation, view_index, out_pose); 114 114 } 115 115 116 + static void 117 + sample_hmd_get_view_poses(struct xrt_device *xdev, 118 + const struct xrt_vec3 *default_eye_relation, 119 + uint64_t at_timestamp_ns, 120 + uint32_t view_count, 121 + struct xrt_space_relation *out_head_relation, 122 + struct xrt_fov *out_fovs, 123 + struct xrt_pose *out_poses) 124 + { 125 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 126 + out_poses); 127 + } 128 + 116 129 struct xrt_device * 117 130 sample_hmd_create(void) 118 131 { ··· 124 137 sh->base.update_inputs = sample_hmd_update_inputs; 125 138 sh->base.get_tracked_pose = sample_hmd_get_tracked_pose; 126 139 sh->base.get_view_pose = sample_hmd_get_view_pose; 140 + sh->base.get_view_poses = sample_hmd_get_view_poses; 127 141 sh->base.destroy = sample_hmd_destroy; 128 142 sh->base.name = XRT_DEVICE_GENERIC_HMD; 129 143 sh->base.device_type = XRT_DEVICE_TYPE_HMD;
+27
src/xrt/drivers/survive/survive_driver.c
··· 52 52 #include "../ht_ctrl_emu/ht_ctrl_emu_interface.h" 53 53 #include "xrt/xrt_config_drivers.h" 54 54 55 + #include "util/u_trace_marker.h" 56 + 55 57 #include "survive_driver.h" 56 58 57 59 // If we haven't gotten a config for devices this long after startup, just start without those devices ··· 462 464 out_pose->orientation = survive->hmd.config.display.rot[view_index]; 463 465 } 464 466 467 + static void 468 + survive_device_get_view_poses(struct xrt_device *xdev, 469 + const struct xrt_vec3 *default_eye_relation, 470 + uint64_t at_timestamp_ns, 471 + uint32_t view_count, 472 + struct xrt_space_relation *out_head_relation, 473 + struct xrt_fov *out_fovs, 474 + struct xrt_pose *out_poses) 475 + { 476 + XRT_TRACE_MARKER(); 477 + 478 + // Only supports two views. 479 + assert(view_count <= 2); 480 + 481 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 482 + out_poses); 483 + 484 + // This is for the Index' canted displays, on the Vive [Pro] they are identity. 485 + struct survive_device *survive = (struct survive_device *)xdev; 486 + for (uint32_t i = 0; i < view_count && i < ARRAY_SIZE(survive->hmd.config.display.rot); i++) { 487 + out_poses[i].orientation = survive->hmd.config.display.rot[i]; 488 + } 489 + } 490 + 465 491 enum InputComponent 466 492 { 467 493 COMP_1D, ··· 831 857 survive->base.update_inputs = survive_device_update_inputs; 832 858 survive->base.get_tracked_pose = survive_device_get_tracked_pose; 833 859 survive->base.get_view_pose = survive_device_get_view_pose; 860 + survive->base.get_view_poses = survive_device_get_view_poses; 834 861 survive->base.tracking_origin = &sys->base; 835 862 836 863 SURVIVE_INFO(survive, "survive HMD present");
+25
src/xrt/drivers/vive/vive_device.c
··· 134 134 out_pose->orientation = d->config.display.rot[view_index]; 135 135 } 136 136 137 + static void 138 + vive_device_get_view_poses(struct xrt_device *xdev, 139 + const struct xrt_vec3 *default_eye_relation, 140 + uint64_t at_timestamp_ns, 141 + uint32_t view_count, 142 + struct xrt_space_relation *out_head_relation, 143 + struct xrt_fov *out_fovs, 144 + struct xrt_pose *out_poses) 145 + { 146 + XRT_TRACE_MARKER(); 147 + 148 + // Only supports two views. 149 + assert(view_count <= 2); 150 + 151 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 152 + out_poses); 153 + 154 + // This is for the Index' canted displays, on the Vive [Pro] they are identity. 155 + struct vive_device *d = vive_device(xdev); 156 + for (uint32_t i = 0; i < view_count && i < ARRAY_SIZE(d->config.display.rot); i++) { 157 + out_poses[i].orientation = d->config.display.rot[i]; 158 + } 159 + } 160 + 137 161 static int 138 162 vive_mainboard_get_device_info(struct vive_device *d) 139 163 { ··· 756 780 d->base.update_inputs = vive_device_update_inputs; 757 781 d->base.get_tracked_pose = vive_device_get_tracked_pose; 758 782 d->base.get_view_pose = vive_device_get_view_pose; 783 + d->base.get_view_poses = vive_device_get_view_poses; 759 784 d->base.destroy = vive_device_destroy; 760 785 d->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 761 786 d->base.name = XRT_DEVICE_GENERIC_HMD;
+14
src/xrt/drivers/wmr/wmr_hmd.c
··· 993 993 } 994 994 995 995 static void 996 + wmr_hmd_get_view_poses(struct xrt_device *xdev, 997 + const struct xrt_vec3 *default_eye_relation, 998 + uint64_t at_timestamp_ns, 999 + uint32_t view_count, 1000 + struct xrt_space_relation *out_head_relation, 1001 + struct xrt_fov *out_fovs, 1002 + struct xrt_pose *out_poses) 1003 + { 1004 + u_device_get_view_poses(xdev, default_eye_relation, at_timestamp_ns, view_count, out_head_relation, out_fovs, 1005 + out_poses); 1006 + } 1007 + 1008 + static void 996 1009 wmr_hmd_destroy(struct xrt_device *xdev) 997 1010 { 998 1011 DRV_TRACE_MARKER(); ··· 1233 1246 wh->base.update_inputs = wmr_hmd_update_inputs; 1234 1247 wh->base.get_tracked_pose = wmr_hmd_get_tracked_pose; 1235 1248 wh->base.get_view_pose = wmr_hmd_get_view_pose; 1249 + wh->base.get_view_poses = wmr_hmd_get_view_poses; 1236 1250 wh->base.destroy = wmr_hmd_destroy; 1237 1251 wh->base.name = XRT_DEVICE_GENERIC_HMD; 1238 1252 wh->base.device_type = XRT_DEVICE_TYPE_HMD;