+91 -64

src/xrt/drivers/sample/sample_hmd.c

··· 1 1 - // Copyright 2020-2021, Collabora, Ltd. 1 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file ··· 12 12 * @ingroup drv_sample 13 13 */ 14 14 15 15 + #include "os/os_time.h" 16 16 + #include "xrt/xrt_defines.h" 15 17 #include "xrt/xrt_device.h" 16 18 19 19 + #include "math/m_relation_history.h" 17 20 #include "math/m_api.h" 18 21 #include "math/m_mathinclude.h" // IWYU pragma: keep 19 22 20 20 - #include "util/u_var.h" 21 21 - #include "util/u_time.h" 22 23 #include "util/u_debug.h" 23 24 #include "util/u_device.h" 25 25 + #include "util/u_distortion_mesh.h" 24 26 #include "util/u_logging.h" 25 25 - #include "util/u_distortion_mesh.h" 27 27 + #include "util/u_misc.h" 28 28 + #include "util/u_time.h" 29 29 + #include "util/u_var.h" 26 30 #include "util/u_visibility_mask.h" 27 31 #include "xrt/xrt_results.h" 28 32 ··· 47 51 struct xrt_pose pose; 48 52 49 53 enum u_logging_level log_level; 54 54 + 55 55 + // has built-in mutex so thread safe 56 56 + struct m_relation_history *relation_hist; 50 57 }; 51 58 52 59 ··· 59 66 60 67 DEBUG_GET_ONCE_LOG_OPTION(sample_log, "SAMPLE_LOG", U_LOGGING_WARN) 61 68 62 62 - #define SH_TRACE(p, ...) U_LOG_XDEV_IFL_T(&sh->base, sh->log_level, __VA_ARGS__) 63 63 - #define SH_DEBUG(p, ...) U_LOG_XDEV_IFL_D(&sh->base, sh->log_level, __VA_ARGS__) 64 64 - #define SH_ERROR(p, ...) U_LOG_XDEV_IFL_E(&sh->base, sh->log_level, __VA_ARGS__) 69 69 + #define HMD_TRACE(hmd, ...) U_LOG_XDEV_IFL_T(&hmd->base, hmd->log_level, __VA_ARGS__) 70 70 + #define HMD_DEBUG(hmd, ...) U_LOG_XDEV_IFL_D(&hmd->base, hmd->log_level, __VA_ARGS__) 71 71 + #define HMD_INFO(hmd, ...) U_LOG_XDEV_IFL_I(&hmd->base, hmd->log_level, __VA_ARGS__) 72 72 + #define HMD_ERROR(hmd, ...) U_LOG_XDEV_IFL_E(&hmd->base, hmd->log_level, __VA_ARGS__) 65 73 66 74 static void 67 75 sample_hmd_destroy(struct xrt_device *xdev) 68 76 { 69 69 - struct sample_hmd *sh = sample_hmd(xdev); 77 77 + struct sample_hmd *hmd = sample_hmd(xdev); 70 78 71 79 // Remove the variable tracking. 72 72 - u_var_remove_root(sh); 80 80 + u_var_remove_root(hmd); 73 81 74 74 - u_device_free(&sh->base); 82 82 + 83 83 + m_relation_history_destroy(&hmd->relation_hist); 84 84 + 85 85 + u_device_free(&hmd->base); 75 86 } 76 87 77 88 static void 78 89 sample_hmd_update_inputs(struct xrt_device *xdev) 79 90 { 80 91 /* 81 81 - * Empty for the sampler driver, if you need to you should 92 92 + * Empty for the sample driver, if you need to you should 82 93 * put code to update the attached inputs fields. If not you can use 83 94 * the u_device_noop_update_inputs helper to make it a no-op. 84 95 */ ··· 90 101 uint64_t at_timestamp_ns, 91 102 struct xrt_space_relation *out_relation) 92 103 { 93 93 - struct sample_hmd *sh = sample_hmd(xdev); 104 104 + struct sample_hmd *hmd = sample_hmd(xdev); 94 105 95 106 if (name != XRT_INPUT_GENERIC_HEAD_POSE) { 96 96 - SH_ERROR(sh, "unknown input name"); 107 107 + HMD_ERROR(hmd, "unknown input name"); 97 108 return; 98 109 } 99 110 100 100 - // Estimate pose at timestamp at_timestamp_ns! 101 101 - math_quat_normalize(&sh->pose.orientation); 102 102 - out_relation->pose = sh->pose; 103 103 - out_relation->relation_flags = (enum xrt_space_relation_flags)(XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | 104 104 - XRT_SPACE_RELATION_POSITION_VALID_BIT | 105 105 - XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT); 111 111 + struct xrt_space_relation relation = XRT_SPACE_RELATION_ZERO; 112 112 + 113 113 + enum m_relation_history_result history_result = 114 114 + m_relation_history_get(hmd->relation_hist, at_timestamp_ns, &relation); 115 115 + if (history_result == M_RELATION_HISTORY_RESULT_INVALID) { 116 116 + // If you get in here, it means you did not push any poses into the relation history. 117 117 + // You may want to handle this differently. 118 118 + HMD_ERROR(hmd, "Internal error: no poses pushed?"); 119 119 + } 120 120 + 121 121 + if ((relation.relation_flags & XRT_SPACE_RELATION_ORIENTATION_VALID_BIT) != 0) { 122 122 + // If we provide an orientation, make sure that it is normalized. 123 123 + math_quat_normalize(&relation.pose.orientation); 124 124 + } 125 125 + 126 126 + *out_relation = relation; 106 127 } 107 128 108 129 static void ··· 128 149 out_poses); // 129 150 } 130 151 131 131 - bool 132 132 - sample_hmd_compute_distortion( 133 133 - struct xrt_device *xdev, uint32_t view, float u, float v, struct xrt_uv_triplet *out_result) 134 134 - { 135 135 - return u_compute_distortion_none(u, u, out_result); 136 136 - } 137 137 - 138 152 xrt_result_t 139 153 sample_hmd_get_visibility_mask(struct xrt_device *xdev, 140 154 enum xrt_visibility_mask_type type, ··· 153 167 enum u_device_alloc_flags flags = 154 168 (enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE); 155 169 156 156 - struct sample_hmd *sh = U_DEVICE_ALLOCATE(struct sample_hmd, flags, 1, 0); 170 170 + struct sample_hmd *hmd = U_DEVICE_ALLOCATE(struct sample_hmd, flags, 1, 0); 157 171 158 172 // This list should be ordered, most preferred first. 159 173 size_t idx = 0; 160 160 - sh->base.hmd->blend_modes[idx++] = XRT_BLEND_MODE_OPAQUE; 161 161 - sh->base.hmd->blend_mode_count = idx; 174 174 + hmd->base.hmd->blend_modes[idx++] = XRT_BLEND_MODE_OPAQUE; 175 175 + hmd->base.hmd->blend_mode_count = idx; 176 176 + 177 177 + hmd->base.update_inputs = sample_hmd_update_inputs; 178 178 + hmd->base.get_tracked_pose = sample_hmd_get_tracked_pose; 179 179 + hmd->base.get_view_poses = sample_hmd_get_view_poses; 180 180 + hmd->base.get_visibility_mask = sample_hmd_get_visibility_mask; 181 181 + hmd->base.destroy = sample_hmd_destroy; 182 182 + 183 183 + // Distortion information, fills in xdev->compute_distortion(). 184 184 + u_distortion_mesh_set_none(&hmd->base); 162 185 163 163 - sh->base.update_inputs = sample_hmd_update_inputs; 164 164 - sh->base.get_tracked_pose = sample_hmd_get_tracked_pose; 165 165 - sh->base.get_view_poses = sample_hmd_get_view_poses; 166 166 - sh->base.compute_distortion = sample_hmd_compute_distortion; 167 167 - sh->base.get_visibility_mask = sample_hmd_get_visibility_mask; 168 168 - sh->base.destroy = sample_hmd_destroy; 186 186 + // populate this with something more complex if required 187 187 + // hmd->base.compute_distortion = sample_hmd_compute_distortion; 169 188 170 170 - sh->pose = (struct xrt_pose)XRT_POSE_IDENTITY; 171 171 - sh->log_level = debug_get_log_option_sample_log(); 189 189 + hmd->pose = (struct xrt_pose)XRT_POSE_IDENTITY; 190 190 + hmd->log_level = debug_get_log_option_sample_log(); 172 191 173 192 // Print name. 174 174 - snprintf(sh->base.str, XRT_DEVICE_NAME_LEN, "Sample HMD"); 175 175 - snprintf(sh->base.serial, XRT_DEVICE_NAME_LEN, "Sample HMD S/N"); 193 193 + snprintf(hmd->base.str, XRT_DEVICE_NAME_LEN, "Sample HMD"); 194 194 + snprintf(hmd->base.serial, XRT_DEVICE_NAME_LEN, "Sample HMD S/N"); 195 195 + 196 196 + m_relation_history_create(&hmd->relation_hist); 176 197 177 198 // Setup input. 178 178 - sh->base.name = XRT_DEVICE_GENERIC_HMD; 179 179 - sh->base.device_type = XRT_DEVICE_TYPE_HMD; 180 180 - sh->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 181 181 - sh->base.orientation_tracking_supported = true; 182 182 - sh->base.position_tracking_supported = false; 199 199 + hmd->base.name = XRT_DEVICE_GENERIC_HMD; 200 200 + hmd->base.device_type = XRT_DEVICE_TYPE_HMD; 201 201 + hmd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE; 202 202 + hmd->base.orientation_tracking_supported = true; 203 203 + hmd->base.position_tracking_supported = true; 183 204 184 205 // Set up display details 185 206 // refresh rate 186 186 - sh->base.hmd->screens[0].nominal_frame_interval_ns = time_s_to_ns(1.0f / 90.0f); 207 207 + hmd->base.hmd->screens[0].nominal_frame_interval_ns = time_s_to_ns(1.0f / 90.0f); 187 208 188 209 const double hFOV = 90 * (M_PI / 180.0); 189 210 const double vFOV = 96.73 * (M_PI / 180.0); ··· 192 213 const double vCOP = 0.5; 193 214 if ( 194 215 /* right eye */ 195 195 - !math_compute_fovs(1, hCOP, hFOV, 1, vCOP, vFOV, &sh->base.hmd->distortion.fov[1]) || 216 216 + !math_compute_fovs(1, hCOP, hFOV, 1, vCOP, vFOV, &hmd->base.hmd->distortion.fov[1]) || 196 217 /* 197 218 * left eye - same as right eye, except the horizontal center of projection is moved in the opposite 198 219 * direction now 199 220 */ 200 200 - !math_compute_fovs(1, 1.0 - hCOP, hFOV, 1, vCOP, vFOV, &sh->base.hmd->distortion.fov[0])) { 221 221 + !math_compute_fovs(1, 1.0 - hCOP, hFOV, 1, vCOP, vFOV, &hmd->base.hmd->distortion.fov[0])) { 201 222 // If those failed, it means our math was impossible. 202 202 - SH_ERROR(sh, "Failed to setup basic device info"); 203 203 - sample_hmd_destroy(&sh->base); 223 223 + HMD_ERROR(hmd, "Failed to setup basic device info"); 224 224 + sample_hmd_destroy(&hmd->base); 204 225 return NULL; 205 226 } 206 227 const int panel_w = 1080; 207 228 const int panel_h = 1200; 208 229 209 230 // Single "screen" (always the case) 210 210 - sh->base.hmd->screens[0].w_pixels = panel_w * 2; 211 211 - sh->base.hmd->screens[0].h_pixels = panel_h; 231 231 + hmd->base.hmd->screens[0].w_pixels = panel_w * 2; 232 232 + hmd->base.hmd->screens[0].h_pixels = panel_h; 212 233 213 234 // Left, Right 214 235 for (uint8_t eye = 0; eye < 2; ++eye) { 215 215 - sh->base.hmd->views[eye].display.w_pixels = panel_w; 216 216 - sh->base.hmd->views[eye].display.h_pixels = panel_h; 217 217 - sh->base.hmd->views[eye].viewport.y_pixels = 0; 218 218 - sh->base.hmd->views[eye].viewport.w_pixels = panel_w; 219 219 - sh->base.hmd->views[eye].viewport.h_pixels = panel_h; 236 236 + hmd->base.hmd->views[eye].display.w_pixels = panel_w; 237 237 + hmd->base.hmd->views[eye].display.h_pixels = panel_h; 238 238 + hmd->base.hmd->views[eye].viewport.y_pixels = 0; 239 239 + hmd->base.hmd->views[eye].viewport.w_pixels = panel_w; 240 240 + hmd->base.hmd->views[eye].viewport.h_pixels = panel_h; 220 241 // if rotation is not identity, the dimensions can get more complex. 221 221 - sh->base.hmd->views[eye].rot = u_device_rotation_ident; 242 242 + hmd->base.hmd->views[eye].rot = u_device_rotation_ident; 222 243 } 223 244 // left eye starts at x=0, right eye starts at x=panel_width 224 224 - sh->base.hmd->views[0].viewport.x_pixels = 0; 225 225 - sh->base.hmd->views[1].viewport.x_pixels = panel_w; 245 245 + hmd->base.hmd->views[0].viewport.x_pixels = 0; 246 246 + hmd->base.hmd->views[1].viewport.x_pixels = panel_w; 226 247 227 248 // Distortion information, fills in xdev->compute_distortion(). 228 228 - u_distortion_mesh_set_none(&sh->base); 249 249 + u_distortion_mesh_set_none(&hmd->base); 250 250 + 251 251 + // Just put an initial identity value in the tracker 252 252 + struct xrt_space_relation identity = XRT_SPACE_RELATION_ZERO; 253 253 + identity.relation_flags = (enum xrt_space_relation_flags)(XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | 254 254 + XRT_SPACE_RELATION_ORIENTATION_VALID_BIT); 255 255 + uint64_t now = os_monotonic_get_ns(); 256 256 + m_relation_history_push(hmd->relation_hist, &identity, now); 229 257 230 258 // Setup variable tracker: Optional but useful for debugging 231 231 - u_var_add_root(sh, "Sample HMD", true); 232 232 - u_var_add_pose(sh, &sh->pose, "pose"); 233 233 - u_var_add_log_level(sh, &sh->log_level, "log_level"); 259 259 + u_var_add_root(hmd, "Sample HMD", true); 260 260 + u_var_add_log_level(hmd, &hmd->log_level, "log_level"); 234 261 235 262 236 236 - return &sh->base; 263 263 + return &hmd->base; 237 264 }

+11 -7

src/xrt/drivers/sample/sample_interface.h

··· 1 1 - // Copyright 2020-2021, Collabora, Ltd. 1 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 - * @brief Interface to sample driver. 5 5 + * @brief Interface to Sample HMD driver. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 * @author Rylie Pavlik <rylie.pavlik@collabora.com> 8 8 * @ingroup drv_sample ··· 15 15 #endif 16 16 17 17 /*! 18 18 - * @defgroup drv_sample Sample driver 18 18 + * @defgroup drv_sample Sample HMD driver 19 19 * @ingroup drv 20 20 * 21 21 - * @brief Simple do-nothing sample driver, that cannot be detected by USB VID/PID 21 21 + * @brief Driver for a Sample HMD. 22 22 + * 23 23 + * Does no actual work. 24 24 + * Assumed to not be detectable by USB VID/PID, 22 25 * and thus exposes an "auto-prober" to explicitly discover the device. 23 26 * 24 27 * See @ref writing-driver for additional information. ··· 30 33 * you can skip the @ref xrt_auto_prober implementation, and instead implement a 31 34 * "found" function that matches the signature expected by xrt_prober_entry::found. 32 35 * See for example @ref hdk_found. 36 36 + * Alternately, you might create a builder or an instance implementation directly. 33 37 */ 34 38 35 39 /*! 36 36 - * Create a auto prober for a sample device. 40 40 + * Create a auto prober for a Sample HMD. 37 41 * 38 42 * @ingroup drv_sample 39 43 */ ··· 41 45 sample_create_auto_prober(void); 42 46 43 47 /*! 44 44 - * Create a sample hmd. 48 48 + * Create a Sample HMD. 45 49 * 46 50 * This is only exposed so that the prober (in one source file) 47 47 - * can call the construction function (in another.) 51 51 + * can call the construction function (in another) 48 52 * @ingroup drv_sample 49 53 */ 50 54 struct xrt_device *

+14 -15

src/xrt/drivers/sample/sample_prober.c

··· 1 1 - // Copyright 2020-2021, Collabora, Ltd. 1 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 // SPDX-License-Identifier: BSL-1.0 3 3 /*! 4 4 * @file 5 5 - * @brief Sample prober code. 5 5 + * @brief "auto-prober" for Sample HMD that can be autodetected but not through USB VID/PID. 6 6 * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 * @ingroup drv_sample 8 8 */ ··· 10 10 #include "xrt/xrt_prober.h" 11 11 12 12 #include "util/u_misc.h" 13 13 - #include "util/u_debug.h" 14 13 15 14 #include "sample_interface.h" 16 15 ··· 25 24 26 25 //! @private @memberof sample_auto_prober 27 26 static inline struct sample_auto_prober * 28 28 - sample_auto_prober(struct xrt_auto_prober *p) 27 27 + sample_auto_prober(struct xrt_auto_prober *xap) 29 28 { 30 30 - return (struct sample_auto_prober *)p; 29 29 + return (struct sample_auto_prober *)xap; 31 30 } 32 31 33 32 //! @private @memberof sample_auto_prober 34 33 static void 35 34 sample_auto_prober_destroy(struct xrt_auto_prober *p) 36 35 { 37 37 - struct sample_auto_prober *sap = sample_auto_prober(p); 36 36 + struct sample_auto_prober *ap = sample_auto_prober(p); 38 37 39 39 - free(sap); 38 38 + free(ap); 40 39 } 41 40 42 41 //! @public @memberof sample_auto_prober ··· 47 46 struct xrt_prober *xp, 48 47 struct xrt_device **out_xdevs) 49 48 { 50 50 - struct sample_auto_prober *sap = sample_auto_prober(xap); 51 51 - (void)sap; 49 49 + struct sample_auto_prober *ap = sample_auto_prober(xap); 50 50 + (void)ap; 52 51 53 53 - // Do not create a sample HMD if we are not looking for HMDs. 52 52 + // Do not create an HMD device if we are not looking for HMDs. 54 53 if (no_hmds) { 55 54 return 0; 56 55 } ··· 62 61 struct xrt_auto_prober * 63 62 sample_create_auto_prober(void) 64 63 { 65 65 - struct sample_auto_prober *sap = U_TYPED_CALLOC(struct sample_auto_prober); 66 66 - sap->base.name = "Sample"; 67 67 - sap->base.destroy = sample_auto_prober_destroy; 68 68 - sap->base.lelo_dallas_autoprobe = sample_auto_prober_autoprobe; 64 64 + struct sample_auto_prober *ap = U_TYPED_CALLOC(struct sample_auto_prober); 65 65 + ap->base.name = "Sample HMD Auto-Prober"; 66 66 + ap->base.destroy = sample_auto_prober_destroy; 67 67 + ap->base.lelo_dallas_autoprobe = sample_auto_prober_autoprobe; 69 68 70 70 - return &sap->base; 69 69 + return &ap->base; 71 70 }