+12 -12

src/xrt/auxiliary/util/u_builders.c

··· 113 113 struct xrt_tracking_origin *right_origin = right ? right->tracking_origin : NULL; 114 114 115 115 if (left_origin != NULL && left_origin->type == XRT_TRACKING_TYPE_NONE) { 116 116 - left_origin->offset.position.x = -0.2f; 117 117 - left_origin->offset.position.y = 1.3f; 118 118 - left_origin->offset.position.z = -0.5f; 116 116 + left_origin->initial_offset.position.x = -0.2f; 117 117 + left_origin->initial_offset.position.y = 1.3f; 118 118 + left_origin->initial_offset.position.z = -0.5f; 119 119 } 120 120 121 121 if (right_origin != NULL && right_origin->type == XRT_TRACKING_TYPE_NONE) { 122 122 - right_origin->offset.position.x = 0.2f; 123 123 - right_origin->offset.position.y = 1.3f; 124 124 - right_origin->offset.position.z = -0.5f; 122 122 + right_origin->initial_offset.position.x = 0.2f; 123 123 + right_origin->initial_offset.position.y = 1.3f; 124 124 + right_origin->initial_offset.position.z = -0.5f; 125 125 } 126 126 127 127 // Head comes last, because left and right may share tracking origin. 128 128 if (head_origin != NULL && head_origin->type == XRT_TRACKING_TYPE_NONE) { 129 129 // "nominal height" 1.6m 130 130 - head_origin->offset.position.x = 0.0f; 131 131 - head_origin->offset.position.y = 1.6f; 132 132 - head_origin->offset.position.z = 0.0f; 130 130 + head_origin->initial_offset.position.x = 0.0f; 131 131 + head_origin->initial_offset.position.y = 1.6f; 132 132 + head_origin->initial_offset.position.z = 0.0f; 133 133 } 134 134 135 135 if (head_origin) { 136 136 - apply_offset(&head_origin->offset.position, global_tracking_origin_offset); 136 136 + apply_offset(&head_origin->initial_offset.position, global_tracking_origin_offset); 137 137 } 138 138 if (left_origin && left_origin != head_origin) { 139 139 - apply_offset(&left->tracking_origin->offset.position, global_tracking_origin_offset); 139 139 + apply_offset(&left->tracking_origin->initial_offset.position, global_tracking_origin_offset); 140 140 } 141 141 if (right_origin && right_origin != head_origin && right_origin != left_origin) { 142 142 - apply_offset(&right->tracking_origin->offset.position, global_tracking_origin_offset); 142 142 + apply_offset(&right->tracking_origin->initial_offset.position, global_tracking_origin_offset); 143 143 } 144 144 } 145 145

+1 -1

src/xrt/auxiliary/util/u_device.c

··· 316 316 if (alloc_tracking) { 317 317 xdev->tracking_origin = (struct xrt_tracking_origin *)(ptr + offset_tracking); 318 318 xdev->tracking_origin->type = XRT_TRACKING_TYPE_NONE; 319 319 - xdev->tracking_origin->offset.orientation.w = 1.0f; 319 319 + xdev->tracking_origin->initial_offset.orientation.w = 1.0f; 320 320 snprintf(xdev->tracking_origin->name, XRT_TRACKING_NAME_LEN, "%s", "No tracking"); 321 321 } 322 322

+1 -1

src/xrt/auxiliary/util/u_space_overseer.c

··· 914 914 if (ptr != NULL) { 915 915 xs = (struct xrt_space *)ptr; 916 916 } else { 917 917 - u_space_overseer_create_offset_space(uso, root, &torig->offset, &xs); 917 917 + u_space_overseer_create_offset_space(uso, root, &torig->initial_offset, &xs); 918 918 u_hashmap_int_insert(torig_map, key, xs); 919 919 } 920 920

+2 -2

src/xrt/drivers/euroc/euroc_device.c

··· 196 196 197 197 xd->tracking_origin = &ed->tracking_origin; 198 198 xd->tracking_origin->type = XRT_TRACKING_TYPE_EXTERNAL_SLAM; 199 199 - xd->tracking_origin->offset.orientation.w = 1.0f; 199 199 + xd->tracking_origin->initial_offset.orientation.w = 1.0f; 200 200 snprintf(xd->tracking_origin->name, XRT_TRACKING_NAME_LEN, "%s %s", dev_name, "SLAM Tracker"); 201 201 202 202 if (is_hmd) { ··· 217 217 u_var_add_root(ed, dev_name, false); 218 218 u_var_add_pose(ed, &ed->pose, "pose"); 219 219 u_var_add_pose(ed, &ed->offset, "offset"); 220 220 - u_var_add_pose(ed, &ed->tracking_origin.offset, "tracking offset"); 220 220 + u_var_add_pose(ed, &ed->tracking_origin.initial_offset, "tracking offset"); 221 221 222 222 bool tracked = xp->tracking->create_tracked_slam(xp->tracking, &ed->slam) >= 0; 223 223 if (!tracked) {

+4 -4

src/xrt/drivers/ht/ht_driver.c

··· 203 203 } 204 204 205 205 htd->base.tracking_origin->type = XRT_TRACKING_TYPE_RGB; 206 206 - htd->base.tracking_origin->offset.position.x = 0.0f; 207 207 - htd->base.tracking_origin->offset.position.y = 0.0f; 208 208 - htd->base.tracking_origin->offset.position.z = 0.0f; 209 209 - htd->base.tracking_origin->offset.orientation.w = 1.0f; 206 206 + htd->base.tracking_origin->initial_offset.position.x = 0.0f; 207 207 + htd->base.tracking_origin->initial_offset.position.y = 0.0f; 208 208 + htd->base.tracking_origin->initial_offset.position.z = 0.0f; 209 209 + htd->base.tracking_origin->initial_offset.orientation.w = 1.0f; 210 210 211 211 htd->base.update_inputs = u_device_noop_update_inputs; 212 212 htd->base.get_hand_tracking = ht_device_get_hand_tracking;

+3 -3

src/xrt/drivers/hydra/hydra_driver.c

··· 595 595 hs->base.type = XRT_TRACKING_TYPE_HYDRA; 596 596 snprintf(hs->base.name, XRT_TRACKING_NAME_LEN, "%s", "Razer Hydra magnetic tracking"); 597 597 // Arbitrary static transform from local space to base. 598 598 - hs->base.offset.position.y = 1.0f; 599 599 - hs->base.offset.position.z = -0.25f; 600 600 - hs->base.offset.orientation.w = 1.0f; 598 598 + hs->base.initial_offset.position.y = 1.0f; 599 599 + hs->base.initial_offset.position.z = -0.25f; 600 600 + hs->base.initial_offset.orientation.w = 1.0f; 601 601 602 602 hs->data_hid = data_hid; 603 603 hs->command_hid = command_hid;

+4 -4

src/xrt/drivers/multi_wrapper/multi.c

··· 109 109 m_space_relation_ident(&in_target_space); 110 110 in_target_space.relation_flags = tracker_relation.relation_flags; 111 111 112 112 - struct xrt_pose *target_offset = &d->tracking_override.target->tracking_origin->offset; 113 113 - struct xrt_pose *tracker_offset = &d->tracking_override.tracker->tracking_origin->offset; 112 112 + struct xrt_pose *target_offset = &d->tracking_override.target->tracking_origin->initial_offset; 113 113 + struct xrt_pose *tracker_offset = &d->tracking_override.tracker->tracking_origin->initial_offset; 114 114 115 115 attached_override(d, &target_relation, target_offset, &tracker_relation, tracker_offset, 116 116 &in_target_space, out_relation); ··· 163 163 m_space_relation_ident(&in_target_space); 164 164 in_target_space.relation_flags = tracker_relation.relation_flags; 165 165 166 166 - struct xrt_pose *target_offset = &d->tracking_override.target->tracking_origin->offset; 167 167 - struct xrt_pose *tracker_offset = &d->tracking_override.tracker->tracking_origin->offset; 166 166 + struct xrt_pose *target_offset = &d->tracking_override.target->tracking_origin->initial_offset; 167 167 + struct xrt_pose *tracker_offset = &d->tracking_override.tracker->tracking_origin->initial_offset; 168 168 169 169 attached_override(d, &out_value->hand_pose, target_offset, &tracker_relation, tracker_offset, 170 170 &in_target_space, &out_value->hand_pose);

+1 -1

src/xrt/drivers/ohmd/oh_device.c

··· 1233 1233 //! @todo: support mix of 3dof and 6dof OpenHMD devices 1234 1234 struct oh_system *sys = U_TYPED_CALLOC(struct oh_system); 1235 1235 sys->base.type = XRT_TRACKING_TYPE_NONE; 1236 1236 - sys->base.offset.orientation.w = 1.0f; 1236 1236 + sys->base.initial_offset.orientation.w = 1.0f; 1237 1237 1238 1238 u_var_add_root(sys, "OpenHMD Wrapper", false); 1239 1239

+1 -1

src/xrt/drivers/realsense/rs_ddev.c

··· 466 466 rs->base.destroy = rs_ddev_destroy; 467 467 rs->base.name = XRT_DEVICE_REALSENSE; 468 468 rs->base.tracking_origin->type = XRT_TRACKING_TYPE_EXTERNAL_SLAM; 469 469 - rs->base.tracking_origin->offset = (struct xrt_pose)XRT_POSE_IDENTITY; 469 469 + rs->base.tracking_origin->initial_offset = (struct xrt_pose)XRT_POSE_IDENTITY; 470 470 471 471 // Print name. 472 472 snprintf(rs->base.str, XRT_DEVICE_NAME_LEN, "Intel RealSense Device-SLAM");

+2 -2

src/xrt/drivers/remote/r_hub.c

··· 415 415 r->base.destroy = r_hub_system_devices_destroy; 416 416 r->base.get_roles = r_hub_system_devices_get_roles; 417 417 r->origin.type = XRT_TRACKING_TYPE_RGB; 418 418 - r->origin.offset = (struct xrt_pose)XRT_POSE_IDENTITY; 418 418 + r->origin.initial_offset = (struct xrt_pose)XRT_POSE_IDENTITY; 419 419 r->reset.head.center = (struct xrt_pose)XRT_POSE_IDENTITY; 420 420 r->reset.head.center.position.y = 1.6f; 421 421 r->reset.left.active = true; ··· 487 487 488 488 struct xrt_space *root = xso->semantic.root; // Convenience 489 489 struct xrt_space *offset = NULL; 490 490 - u_space_overseer_create_offset_space(uso, root, &r->origin.offset, &offset); 490 490 + u_space_overseer_create_offset_space(uso, root, &r->origin.initial_offset, &offset); 491 491 492 492 for (uint32_t i = 0; i < r->base.xdev_count; i++) { 493 493 u_space_overseer_link_space_to_device(uso, offset, r->base.xdevs[i]);

+1 -1

src/xrt/drivers/rift_s/rift_s.c

··· 158 158 159 159 struct rift_s_system *sys = U_TYPED_CALLOC(struct rift_s_system); 160 160 sys->base.type = XRT_TRACKING_TYPE_NONE; 161 161 - sys->base.offset.orientation.w = 1.0f; 161 161 + sys->base.initial_offset.orientation.w = 1.0f; 162 162 163 163 /* Init refcount */ 164 164 sys->ref.count = 1;

+1 -1

src/xrt/drivers/steamvr_lh/steamvr_lh.cpp

··· 115 115 c->providers = std::move(providers); 116 116 std::strncpy(c->name, "SteamVR Lighthouse Tracking", XRT_TRACKING_NAME_LEN); 117 117 c->type = XRT_TRACKING_TYPE_LIGHTHOUSE; 118 118 - c->offset = XRT_POSE_IDENTITY; 118 118 + c->initial_offset = XRT_POSE_IDENTITY; 119 119 for (vr::IServerTrackedDeviceProvider *const &driver : c->providers) { 120 120 vr::EVRInitError err = driver->Init(c.get()); 121 121 if (err != vr::VRInitError_None) {

+4 -4

src/xrt/drivers/survive/survive_driver.c

··· 1336 1336 ss->ctx = actx; 1337 1337 ss->base.type = XRT_TRACKING_TYPE_LIGHTHOUSE; 1338 1338 snprintf(ss->base.name, XRT_TRACKING_NAME_LEN, "%s", "Libsurvive Tracking"); 1339 1339 - ss->base.offset.position.x = 0.0f; 1340 1340 - ss->base.offset.position.y = 0.0f; 1341 1341 - ss->base.offset.position.z = 0.0f; 1342 1342 - ss->base.offset.orientation.w = 1.0f; 1339 1339 + ss->base.initial_offset.position.x = 0.0f; 1340 1340 + ss->base.initial_offset.position.y = 0.0f; 1341 1341 + ss->base.initial_offset.position.z = 0.0f; 1342 1342 + ss->base.initial_offset.orientation.w = 1.0f; 1343 1343 ss->timecode_offset_ms = (struct u_var_draggable_f32){ 1344 1344 .val = debug_get_float_option_survive_timecode_offset_ms(), 1345 1345 .min = -20.0,

+1 -1

src/xrt/drivers/twrap/twrap_slam.c

··· 176 176 dx->base.destroy = twrap_slam_destroy; 177 177 dx->base.name = name; 178 178 dx->base.tracking_origin->type = XRT_TRACKING_TYPE_OTHER; 179 179 - dx->base.tracking_origin->offset = (struct xrt_pose)XRT_POSE_IDENTITY; 179 179 + dx->base.tracking_origin->initial_offset = (struct xrt_pose)XRT_POSE_IDENTITY; 180 180 dx->base.inputs[0].name = XRT_INPUT_GENERIC_TRACKER_POSE; 181 181 dx->base.orientation_tracking_supported = true; 182 182 dx->base.position_tracking_supported = true;

+1 -1

src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp

··· 387 387 ulv2d->base.tracking_origin = &ulv2d->tracking_origin; 388 388 ulv2d->base.tracking_origin->type = XRT_TRACKING_TYPE_OTHER; 389 389 390 390 - math_pose_identity(&ulv2d->base.tracking_origin->offset); 390 390 + math_pose_identity(&ulv2d->base.tracking_origin->initial_offset); 391 391 392 392 ulv2d->log_level = debug_get_log_option_ulv2_log(); 393 393

+1 -1

src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp

··· 310 310 ulv5d->base.tracking_origin = &ulv5d->tracking_origin; 311 311 ulv5d->base.tracking_origin->type = XRT_TRACKING_TYPE_OTHER; 312 312 313 313 - math_pose_identity(&ulv5d->base.tracking_origin->offset); 313 313 + math_pose_identity(&ulv5d->base.tracking_origin->initial_offset); 314 314 315 315 ulv5d->log_level = debug_get_log_option_ulv5_log(); 316 316

+3 -3

src/xrt/include/xrt/xrt_tracking.h

··· 76 76 enum xrt_tracking_type type; 77 77 78 78 /*! 79 79 - * Read and written to by the state-tracker using the device(s) 80 80 - * this tracking system is tracking. 79 79 + * Read-only. Set once by the builder, or in some cases, the driver. 80 80 + * With some systems, the offset may be changed at runtime using the space overseer. 81 81 */ 82 82 - struct xrt_pose offset; 82 82 + struct xrt_pose initial_offset; 83 83 }; 84 84 85 85 /*!

+2 -2

src/xrt/ipc/client/ipc_client_instance.c

··· 283 283 memcpy(xtrack->name, ism->itracks[i].name, sizeof(xtrack->name)); 284 284 285 285 xtrack->type = ism->itracks[i].type; 286 286 - xtrack->offset = ism->itracks[i].offset; 286 286 + xtrack->initial_offset = ism->itracks[i].offset; 287 287 ii->xtracks[count++] = xtrack; 288 288 289 289 u_var_add_root(xtrack, "Tracking origin", true); 290 290 u_var_add_ro_text(xtrack, xtrack->name, "name"); 291 291 - u_var_add_pose(xtrack, &xtrack->offset, "offset"); 291 291 + u_var_add_pose(xtrack, &xtrack->initial_offset, "offset"); 292 292 } 293 293 294 294 ii->xtrack_count = count;

+1 -1

src/xrt/ipc/server/ipc_server_process.c

··· 322 322 struct ipc_shared_tracking_origin *itrack = &ism->itracks[count++]; 323 323 memcpy(itrack->name, xtrack->name, sizeof(itrack->name)); 324 324 itrack->type = xtrack->type; 325 325 - itrack->offset = xtrack->offset; 325 325 + itrack->offset = xtrack->initial_offset; 326 326 } 327 327 328 328 ism->itrack_count = count;

+1 -1

src/xrt/state_trackers/oxr/oxr_session_frame_end.c

··· 1789 1789 do_synchronize_state_change(log, sess); 1790 1790 1791 1791 struct xrt_pose inv_offset = {0}; 1792 1792 - math_pose_invert(&xdev->tracking_origin->offset, &inv_offset); 1792 1792 + math_pose_invert(&xdev->tracking_origin->initial_offset, &inv_offset); 1793 1793 1794 1794 struct xrt_layer_frame_data data = { 1795 1795 .frame_id = sess->frame_id.begun,

+4 -4

src/xrt/state_trackers/prober/p_tracking.c

··· 421 421 fact->base.create_tracked_psvr = p_factory_create_tracked_psvr; 422 422 fact->base.create_tracked_slam = p_factory_create_tracked_slam; 423 423 fact->origin.type = XRT_TRACKING_TYPE_RGB; 424 424 - fact->origin.offset.orientation.y = 1.0f; 425 425 - fact->origin.offset.position.z = -2.0f; 426 426 - fact->origin.offset.position.y = 1.0f; 424 424 + fact->origin.initial_offset.orientation.y = 1.0f; 425 425 + fact->origin.initial_offset.position.z = -2.0f; 426 426 + fact->origin.initial_offset.position.y = 1.0f; 427 427 fact->p = p; 428 428 429 429 snprintf(fact->origin.name, sizeof(fact->origin.name), "PSVR & PSMV tracking"); 430 430 431 431 u_var_add_root(fact, "Tracking Factory", false); 432 432 - u_var_add_pose(fact, &fact->origin.offset, "offset"); 432 432 + u_var_add_pose(fact, &fact->origin.initial_offset, "offset"); 433 433 434 434 // Finally set us as the tracking factory. 435 435 p->base.tracking = &fact->base;

+2 -2

src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp

··· 881 881 struct xrt_space_relation rel; 882 882 xrt_device_get_tracked_pose(m_xdev, grip_name, now_ns, &rel); 883 883 884 884 - struct xrt_pose *offset = &m_xdev->tracking_origin->offset; 884 884 + struct xrt_pose *offset = &m_xdev->tracking_origin->initial_offset; 885 885 886 886 struct xrt_relation_chain chain = {}; 887 887 m_relation_chain_push_relation(&chain, &rel); ··· 1268 1268 struct xrt_space_relation rel; 1269 1269 xrt_device_get_tracked_pose(m_xdev, XRT_INPUT_GENERIC_HEAD_POSE, now_ns, &rel); 1270 1270 1271 1271 - struct xrt_pose *offset = &m_xdev->tracking_origin->offset; 1271 1271 + struct xrt_pose *offset = &m_xdev->tracking_origin->initial_offset; 1272 1272 1273 1273 struct xrt_relation_chain chain = {}; 1274 1274 m_relation_chain_push_relation(&chain, &rel);

+3 -3

src/xrt/targets/common/target_builder_rgb_tracking.c

··· 301 301 build.xfctx = xfctx; 302 302 build.origin = origin; 303 303 build.origin->type = XRT_TRACKING_TYPE_RGB; 304 304 - build.origin->offset.orientation.y = 1.0f; 305 305 - build.origin->offset.position.z = -2.0f; 306 306 - build.origin->offset.position.y = 1.0f; 304 304 + build.origin->initial_offset.orientation.y = 1.0f; 305 305 + build.origin->initial_offset.position.z = -2.0f; 306 306 + build.origin->initial_offset.position.y = 1.0f; 307 307 308 308 setup_pipeline(xp, &build); 309 309 #else

+1 -1

src/xrt/targets/sdl_test/sdl_device.c

··· 120 120 u_distortion_mesh_set_none(xdev); 121 121 122 122 // Tracking origin. 123 123 - xdev->tracking_origin->offset = (struct xrt_pose)XRT_POSE_IDENTITY; 123 123 + xdev->tracking_origin->initial_offset = (struct xrt_pose)XRT_POSE_IDENTITY; 124 124 xdev->tracking_origin->type = XRT_TRACKING_TYPE_OTHER; 125 125 snprintf(xdev->tracking_origin->name, XRT_TRACKING_NAME_LEN, "SDL Tracking"); 126 126 }