xrt: Make the supported fields on xrt_device be a struct

This makes it trivial for the IPC layer to correctly expose the
supported functionality and methods of the device. As I did this change
I noticed multiple fields that were not copied over in the IPC layer.

Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2466>

src/xrt/auxiliary/util/u_space_overseer.c

···
 		xdev = uso->notify;
 	}
 
-	if (xdev == NULL || !xdev->ref_space_usage_supported) {
+	if (xdev == NULL || !xdev->supported.ref_space_usage) {
 		return;
 	}
 
···
 	xrt_space_reference(&uso->base.semantic.local, NULL);
 	xrt_space_reference(&uso->base.semantic.unbounded, NULL);
 
-	if (head != NULL && head->stage_supported) {
+	if (head != NULL && head->supported.stage) {
 		// stage poses are polled from the driver
 		u_space_overseer_create_pose_space(uso, head, XRT_INPUT_GENERIC_STAGE_SPACE_POSE,
 		                                   &uso->base.semantic.stage);

src/xrt/auxiliary/util/u_system_helpers.c

···
 	for (uint32_t i = 0; i < xsysd->xdev_count; i++) {
 		struct xrt_device *xdev = xsysd->xdevs[i];
 
-		if (xdev == NULL || !xdev->hand_tracking_supported) {
+		if (xdev == NULL || !xdev->supported.hand_tracking) {
 			continue;
 		}
 

src/xrt/drivers/android/android_sensors.c

···
 	u_var_add_ro_vec3_f32(d, &d->fusion.last.accel, "last.accel");
 	u_var_add_ro_vec3_f32(d, &d->fusion.last.gyro, "last.gyro");
 
-	d->base.orientation_tracking_supported = true;
-	d->base.position_tracking_supported = false;
+	d->base.supported.orientation_tracking = true;
+	d->base.supported.position_tracking = false;
 
 	// Distortion information.
 	u_distortion_mesh_fill_in_compute(&d->base);

src/xrt/drivers/arduino/arduino_device.c

···
 	u_var_add_ro_vec3_f32(ad, &ad->fusion.last.accel, "last.accel");
 	u_var_add_ro_vec3_f32(ad, &ad->fusion.last.gyro, "last.gyro");
 
-	ad->base.orientation_tracking_supported = true;
-	ad->base.position_tracking_supported = false;
+	ad->base.supported.orientation_tracking = true;
+	ad->base.supported.position_tracking = false;
 	ad->base.device_type = XRT_DEVICE_TYPE_ANY_HAND_CONTROLLER;
 
 	ARDUINO_DEBUG(ad, "Created device!");

src/xrt/drivers/daydream/daydream_device.c

···
 	u_var_add_ro_vec3_f32(dd, &dd->fusion.last.accel, "last.accel");
 	u_var_add_ro_vec3_f32(dd, &dd->fusion.last.gyro, "last.gyro");
 
-	dd->base.orientation_tracking_supported = true;
-	dd->base.position_tracking_supported = false;
+	dd->base.supported.orientation_tracking = true;
+	dd->base.supported.position_tracking = false;
 	dd->base.device_type = XRT_DEVICE_TYPE_ANY_HAND_CONTROLLER;
 
 	DAYDREAM_DEBUG(dd, "Created device!");

src/xrt/drivers/hdk/hdk_device.cpp

···
 		u_device_dump_config(&hd->base, __func__, hd->base.str);
 	}
 
-	hd->base.orientation_tracking_supported = true;
-	hd->base.position_tracking_supported = false;
+	hd->base.supported.orientation_tracking = true;
+	hd->base.supported.position_tracking = false;
 	hd->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 	return hd;

src/xrt/drivers/ht/ht_driver.c

···
 	// Yes, you need all of these. Yes, I tried disabling them all one at a time. You need all of these.
 	htd->base.name = XRT_DEVICE_HAND_TRACKER;
 	htd->base.device_type = XRT_DEVICE_TYPE_HAND_TRACKER;
-	htd->base.orientation_tracking_supported = true;
-	htd->base.position_tracking_supported = true;
-	htd->base.hand_tracking_supported = true;
+	htd->base.supported.orientation_tracking = true;
+	htd->base.supported.position_tracking = true;
+	htd->base.supported.hand_tracking = true;
 
 	htd->sync = sync;
 

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

···
 		cemud[i]->base.tracking_origin = hands->tracking_origin;
 
 		cemud[i]->base.name = XRT_DEVICE_SIMPLE_CONTROLLER;
-		cemud[i]->base.hand_tracking_supported = true;
-		cemud[i]->base.orientation_tracking_supported = true;
-		cemud[i]->base.position_tracking_supported = true;
+		cemud[i]->base.supported.hand_tracking = true;
+		cemud[i]->base.supported.orientation_tracking = true;
+		cemud[i]->base.supported.position_tracking = true;
 
 
 		cemud[i]->base.inputs[CEMU_INDEX_HAND_TRACKING].name =

src/xrt/drivers/hydra/hydra_driver.c

···
 
 		hd->base.tracking_origin = &hs->base;
 
-		hd->base.position_tracking_supported = true;
-		hd->base.orientation_tracking_supported = true;
+		hd->base.supported.position_tracking = true;
+		hd->base.supported.orientation_tracking = true;
 		hd->base.device_type = XRT_DEVICE_TYPE_ANY_HAND_CONTROLLER;
 
 		out_xdevs[i] = &(hd->base);

src/xrt/drivers/multi_wrapper/multi.c

···
 	d->base = *tracking_override_target;
 
 	// but take orientation and position tracking capabilities from tracker
-	d->base.orientation_tracking_supported = tracking_override_tracker->orientation_tracking_supported;
-	d->base.position_tracking_supported = tracking_override_tracker->position_tracking_supported;
+	d->base.supported.orientation_tracking = tracking_override_tracker->supported.orientation_tracking;
+	d->base.supported.position_tracking = tracking_override_tracker->supported.position_tracking;
 
 	// because we use the tracking data of the tracker, we use its tracking origin instead
 	d->base.tracking_origin = tracking_override_tracker->tracking_origin;

src/xrt/drivers/north_star/ns_hmd.c

···
 	    XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT);
 	// Appeases the inner workings of Monado for when there's no head tracker and we're giving a fake pose through
 	// the debug gui
-	ns->base.orientation_tracking_supported = true;
-	ns->base.position_tracking_supported = true;
+	ns->base.supported.orientation_tracking = true;
+	ns->base.supported.position_tracking = true;
 	ns->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 
···
 	// Setup variable tracker.
 	u_var_add_root(ns, "North Star", true);
 	u_var_add_pose(ns, &ns->no_tracker_relation.pose, "pose");
-	ns->base.orientation_tracking_supported = true;
+	ns->base.supported.orientation_tracking = true;
 	ns->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 	size_t idx = 0;

src/xrt/drivers/ohmd/oh_device.c

···
 		u_device_dump_config(&ohd->base, __func__, prod);
 	}
 
-	ohd->base.orientation_tracking_supported = (device_flags & OHMD_DEVICE_FLAGS_ROTATIONAL_TRACKING) != 0;
-	ohd->base.position_tracking_supported = (device_flags & OHMD_DEVICE_FLAGS_POSITIONAL_TRACKING) != 0;
+	ohd->base.supported.orientation_tracking = (device_flags & OHMD_DEVICE_FLAGS_ROTATIONAL_TRACKING) != 0;
+	ohd->base.supported.position_tracking = (device_flags & OHMD_DEVICE_FLAGS_POSITIONAL_TRACKING) != 0;
 	ohd->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 
···
 	snprintf(ohd->base.str, XRT_DEVICE_NAME_LEN, "%s (OpenHMD)", prod);
 	snprintf(ohd->base.serial, XRT_DEVICE_NAME_LEN, "%s (OpenHMD)", prod);
 
-	ohd->base.orientation_tracking_supported = (device_flags & OHMD_DEVICE_FLAGS_ROTATIONAL_TRACKING) != 0;
-	ohd->base.position_tracking_supported = (device_flags & OHMD_DEVICE_FLAGS_POSITIONAL_TRACKING) != 0;
+	ohd->base.supported.orientation_tracking = (device_flags & OHMD_DEVICE_FLAGS_ROTATIONAL_TRACKING) != 0;
+	ohd->base.supported.position_tracking = (device_flags & OHMD_DEVICE_FLAGS_POSITIONAL_TRACKING) != 0;
 	ohd->base.device_type = device_type;
 
 	ohmd_device_geti(ohd->dev, OHMD_CONTROLS_HINTS, ohd->controls_fn);
···
 
 			sys->devices[OHMD_HMD_INDEX] = hmd;
 
-			if (hmd->base.position_tracking_supported) {
+			if (hmd->base.supported.position_tracking) {
 				sys->base.type = XRT_TRACKING_TYPE_OTHER;
 			}
 

src/xrt/drivers/opengloves/opengloves_device.c

···
 	od->base.inputs[OPENGLOVES_INPUT_INDEX_HAND_TRACKING].name =
 	    od->hand == XRT_HAND_LEFT ? XRT_INPUT_GENERIC_HAND_TRACKING_LEFT : XRT_INPUT_GENERIC_HAND_TRACKING_RIGHT;
 
-	od->base.hand_tracking_supported = true;
-	od->base.force_feedback_supported = true;
+	od->base.supported.hand_tracking = true;
+	od->base.supported.force_feedback = true;
 
 	// inputs
 	od->base.update_inputs = opengloves_device_update_inputs;

src/xrt/drivers/psmv/psmv_driver.c

···
 	u_var_add_log_level(psmv, &psmv->log_level, "Log level");
 	// clang-format on
 
-	psmv->base.orientation_tracking_supported = true;
-	psmv->base.position_tracking_supported = psmv->ball != NULL;
+	psmv->base.supported.orientation_tracking = true;
+	psmv->base.supported.position_tracking = psmv->ball != NULL;
 	psmv->base.device_type = XRT_DEVICE_TYPE_ANY_HAND_CONTROLLER;
 
 	// And finally done

src/xrt/drivers/pssense/pssense_driver.c

···
 	pssense->base.get_tracked_pose = pssense_get_tracked_pose;
 	pssense->base.get_battery_status = pssense_get_battery_status;
 	pssense->base.destroy = pssense_device_destroy;
-	pssense->base.orientation_tracking_supported = true;
-	pssense->base.battery_status_supported = true;
+	pssense->base.supported.orientation_tracking = true;
+	pssense->base.supported.battery_status = true;
 
 	pssense->base.binding_profiles = binding_profiles_pssense;
 	pssense->base.binding_profile_count = ARRAY_SIZE(binding_profiles_pssense);

src/xrt/drivers/psvr/psvr_device.c

···
 		psvr->base.tracking_origin = psvr->tracker->origin;
 	}
 
-	psvr->base.orientation_tracking_supported = true;
-	psvr->base.position_tracking_supported = psvr->tracker != NULL;
+	psvr->base.supported.orientation_tracking = true;
+	psvr->base.supported.position_tracking = psvr->tracker != NULL;
 	psvr->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 	PSVR_DEBUG(psvr, "YES!");

src/xrt/drivers/realsense/rs_ddev.c

···
 		return NULL;
 	}
 
-	rs->base.orientation_tracking_supported = true;
-	rs->base.position_tracking_supported = true;
+	rs->base.supported.orientation_tracking = true;
+	rs->base.supported.position_tracking = true;
 	rs->base.device_type = XRT_DEVICE_TYPE_GENERIC_TRACKER;
 
 	return &rs->base;

src/xrt/drivers/realsense/rs_hdev.c

···
 
 	xd->inputs[0].name = XRT_INPUT_GENERIC_TRACKER_POSE;
 
-	xd->orientation_tracking_supported = true;
-	xd->position_tracking_supported = true;
+	xd->supported.orientation_tracking = true;
+	xd->supported.position_tracking = true;
 
 	xd->update_inputs = u_device_noop_update_inputs;
 	xd->get_tracked_pose = rs_hdev_get_tracked_pose;

src/xrt/drivers/remote/r_device.c

···
 	rd->base.set_output = r_device_set_output;
 	rd->base.destroy = r_device_destroy;
 	rd->base.tracking_origin = &r->origin;
-	rd->base.orientation_tracking_supported = true;
-	rd->base.position_tracking_supported = true;
-	rd->base.hand_tracking_supported = true;
+	rd->base.supported.orientation_tracking = true;
+	rd->base.supported.position_tracking = true;
+	rd->base.supported.hand_tracking = true;
 	rd->base.name = XRT_DEVICE_INDEX_CONTROLLER;
 	rd->base.binding_profiles = vive_binding_profiles_index;
 	rd->base.binding_profile_count = vive_binding_profiles_index_count;

src/xrt/drivers/remote/r_hmd.c

···
 	rh->base.set_output = r_hmd_set_output;
 	rh->base.destroy = r_hmd_destroy;
 	rh->base.tracking_origin = &r->origin;
-	rh->base.orientation_tracking_supported = true;
-	rh->base.position_tracking_supported = true;
-	rh->base.hand_tracking_supported = false;
+	rh->base.supported.orientation_tracking = true;
+	rh->base.supported.position_tracking = true;
+	rh->base.supported.hand_tracking = false;
 	rh->base.name = XRT_DEVICE_GENERIC_HMD;
 	rh->base.device_type = XRT_DEVICE_TYPE_HMD;
 	rh->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;

src/xrt/drivers/rokid/rokid_hmd.c

···
 	rokid->base.name = XRT_DEVICE_GENERIC_HMD;
 	rokid->base.device_type = XRT_DEVICE_TYPE_HMD;
 	rokid->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
-	rokid->base.orientation_tracking_supported = true;
-	rokid->base.position_tracking_supported = false;
+	rokid->base.supported.orientation_tracking = true;
+	rokid->base.supported.position_tracking = false;
 
 	// Set up display details
 	// refresh rate

src/xrt/drivers/sample/sample_hmd.c

···
 	hmd->base.name = XRT_DEVICE_GENERIC_HMD;
 	hmd->base.device_type = XRT_DEVICE_TYPE_HMD;
 	hmd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
-	hmd->base.orientation_tracking_supported = true;
-	hmd->base.position_tracking_supported = true;
+	hmd->base.supported.orientation_tracking = true;
+	hmd->base.supported.position_tracking = true;
 
 	// Set up display details
 	// refresh rate

src/xrt/drivers/simula/svr_hmd.c

···
 	svr->base.name = XRT_DEVICE_GENERIC_HMD;
 
 	// Sorta a lie, we have to do this to make the state tracker happy. (Should multi.c override these?)
-	svr->base.orientation_tracking_supported = true;
-	svr->base.position_tracking_supported = true;
+	svr->base.supported.orientation_tracking = true;
+	svr->base.supported.position_tracking = true;
 
 	svr->base.device_type = XRT_DEVICE_TYPE_HMD;
 
···
 
 	// Setup variable tracker.
 	u_var_add_root(svr, "Simula HMD", true);
-	svr->base.orientation_tracking_supported = true;
+	svr->base.supported.orientation_tracking = true;
 	svr->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 	size_t idx = 0;

src/xrt/drivers/simulated/simulated_controller.c

···
 	sd->base.set_output = simulated_device_set_output;
 	sd->base.destroy = simulated_device_destroy;
 	sd->base.tracking_origin = origin;
-	sd->base.orientation_tracking_supported = true;
-	sd->base.position_tracking_supported = true;
-	sd->base.hand_tracking_supported = false;
+	sd->base.supported.orientation_tracking = true;
+	sd->base.supported.position_tracking = true;
+	sd->base.supported.hand_tracking = false;
 	sd->base.name = name;
 	sd->base.device_type = type;
 	sd->base.binding_profiles = binding_profiles;

src/xrt/drivers/simulated/simulated_hmd.c

···
 	hmd->base.destroy = simulated_hmd_destroy;
 	hmd->base.name = XRT_DEVICE_GENERIC_HMD;
 	hmd->base.device_type = XRT_DEVICE_TYPE_HMD;
-	hmd->base.ref_space_usage_supported = true;
+	hmd->base.supported.ref_space_usage = true;
 	hmd->pose.orientation.w = 1.0f; // All other values set to zero.
 	hmd->center = *center;
 	hmd->created_ns = os_monotonic_get_ns();

src/xrt/drivers/steamvr_lh/device.cpp

···
 	std::strncpy(this->serial, builder.serial, XRT_DEVICE_NAME_LEN - 1);
 	this->serial[XRT_DEVICE_NAME_LEN - 1] = 0;
 	this->tracking_origin = ctx.get();
-	this->orientation_tracking_supported = true;
-	this->position_tracking_supported = true;
-	this->hand_tracking_supported = true;
-	this->force_feedback_supported = false;
-	this->form_factor_check_supported = false;
-	this->battery_status_supported = true;
+	this->supported.orientation_tracking = true;
+	this->supported.position_tracking = true;
+	this->supported.hand_tracking = true;
+	this->supported.force_feedback = false;
+	this->supported.form_factor_check = false;
+	this->supported.battery_status = true;
 
 	this->xrt_device::update_inputs = &device_bouncer<Device, &Device::update_inputs, xrt_result_t>;
 #define SETUP_MEMBER_FUNC(name) this->xrt_device::name = &device_bouncer<Device, &Device::name>

src/xrt/drivers/survive/survive_driver.c

···
 	survive->base.compute_distortion = compute_distortion;
 	survive->base.get_battery_status = survive_device_get_battery_status;
 
-	survive->base.orientation_tracking_supported = true;
-	survive->base.position_tracking_supported = true;
+	survive->base.supported.orientation_tracking = true;
+	survive->base.supported.position_tracking = true;
+	survive->base.supported.battery_status = true;
 	survive->base.device_type = XRT_DEVICE_TYPE_HMD;
-	survive->base.battery_status_supported = true;
 
 	survive->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
 
···
 		survive->base.binding_profile_count = vive_binding_profiles_index_count;
 
 		survive->base.get_hand_tracking = survive_controller_get_hand_tracking;
-		survive->base.hand_tracking_supported = !debug_get_bool_option_survive_disable_hand_emulation();
+		survive->base.supported.hand_tracking = !debug_get_bool_option_survive_disable_hand_emulation();
 
 	} else if (survive->ctrl.config.variant == CONTROLLER_VIVE_WAND) {
 		survive->base.name = XRT_DEVICE_VIVE_WAND;
···
 		survive->base.inputs[VIVE_TRACKER_POSE].name = XRT_INPUT_GENERIC_TRACKER_POSE;
 	}
 
-	survive->base.orientation_tracking_supported = true;
-	survive->base.position_tracking_supported = true;
-	survive->base.battery_status_supported = true;
+	survive->base.supported.orientation_tracking = true;
+	survive->base.supported.position_tracking = true;
+	survive->base.supported.battery_status = true;
 
 	survive->last_inputs = U_TYPED_ARRAY_CALLOC(struct xrt_input, survive->base.input_count);
 	survive->num_last_inputs = survive->base.input_count;

src/xrt/drivers/twrap/twrap_slam.c

···
 	dx->base.name = name;
 	dx->base.tracking_origin->type = XRT_TRACKING_TYPE_OTHER;
 	dx->base.inputs[0].name = XRT_INPUT_GENERIC_TRACKER_POSE;
-	dx->base.orientation_tracking_supported = true;
-	dx->base.position_tracking_supported = true;
+	dx->base.supported.orientation_tracking = true;
+	dx->base.supported.position_tracking = true;
 	dx->base.device_type = XRT_DEVICE_TYPE_GENERIC_TRACKER;
 
 

src/xrt/drivers/ultraleap_v2/ulv2_driver.cpp

···
 	ulv2d->base.name = XRT_DEVICE_HAND_TRACKER;
 
 	ulv2d->base.device_type = XRT_DEVICE_TYPE_HAND_TRACKER;
-	ulv2d->base.hand_tracking_supported = true;
+	ulv2d->base.supported.hand_tracking = true;
 
 	u_var_add_root(ulv2d, "Leap Motion v2 driver", true);
 	u_var_add_ro_text(ulv2d, ulv2d->base.str, "Name");

src/xrt/drivers/ultraleap_v5/ulv5_driver.cpp

···
 	ulv5d->base.name = XRT_DEVICE_HAND_TRACKER;
 
 	ulv5d->base.device_type = XRT_DEVICE_TYPE_HAND_TRACKER;
-	ulv5d->base.hand_tracking_supported = true;
+	ulv5d->base.supported.hand_tracking = true;
 
 	u_var_add_root(ulv5d, "Leap Motion v5 driver", true);
 	u_var_add_ro_text(ulv5d, ulv5d->base.str, "Name");

src/xrt/drivers/vive/vive_controller.c

···
 	}
 
 	VIVE_DEBUG(d, "Opened vive controller!\n");
-	d->base.orientation_tracking_supported = true;
-	d->base.position_tracking_supported = false;
-	d->base.hand_tracking_supported =
+	d->base.supported.orientation_tracking = true;
+	d->base.supported.position_tracking = false;
+	d->base.supported.hand_tracking =
 	    d->config.variant == CONTROLLER_INDEX_LEFT || d->config.variant == CONTROLLER_INDEX_RIGHT;
 
 	vive_controller_setup_ui(d);

src/xrt/drivers/vive/vive_device.c

···
 	bool hand_supported = status.hand_supported;
 	bool hand_enabled = status.hand_enabled;
 
-	d->base.orientation_tracking_supported = dof3_enabled || slam_enabled;
-	d->base.position_tracking_supported = slam_enabled;
-	d->base.hand_tracking_supported = false; // this is handled by a separate hand device
+	d->base.supported.orientation_tracking = dof3_enabled || slam_enabled;
+	d->base.supported.position_tracking = slam_enabled;
+	d->base.supported.hand_tracking = false; // this is handled by a separate hand device
 	d->base.device_type = XRT_DEVICE_TYPE_HMD;
 
 	d->tracking.slam_enabled = slam_enabled;

src/xrt/drivers/wmr/wmr_controller_base.c

···
 
 	wcb->base.name = XRT_DEVICE_WMR_CONTROLLER;
 	wcb->base.device_type = controller_type;
-	wcb->base.orientation_tracking_supported = true;
-	wcb->base.position_tracking_supported = false;
-	wcb->base.hand_tracking_supported = false;
+	wcb->base.supported.orientation_tracking = true;
+	wcb->base.supported.position_tracking = false;
+	wcb->base.supported.hand_tracking = false;
 
 	m_imu_3dof_init(&wcb->fusion, M_IMU_3DOF_USE_GRAVITY_DUR_20MS);
 

src/xrt/drivers/wmr/wmr_hmd.c

···
 #endif
 	bool hand_enabled = hand_supported && hand_wanted;
 
-	wh->base.orientation_tracking_supported = dof3_enabled || slam_enabled;
-	wh->base.position_tracking_supported = slam_enabled;
-	wh->base.hand_tracking_supported = false; // out_handtracker will handle it
+	wh->base.supported.orientation_tracking = dof3_enabled || slam_enabled;
+	wh->base.supported.position_tracking = slam_enabled;
+	wh->base.supported.hand_tracking = false; // out_handtracker will handle it
 
 	wh->tracking.slam_enabled = slam_enabled;
 	wh->tracking.hand_enabled = hand_enabled;

src/xrt/drivers/xreal_air/xreal_air_hmd.c

···
 	hmd->base.name = XRT_DEVICE_GENERIC_HMD;
 	hmd->base.device_type = XRT_DEVICE_TYPE_HMD;
 	hmd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
-	hmd->base.orientation_tracking_supported = true;
-	hmd->base.position_tracking_supported = false;
+	hmd->base.supported.orientation_tracking = true;
+	hmd->base.supported.position_tracking = false;
 
 	// Set up display details refresh rate
 	hmd->base.hmd->screens[0].nominal_frame_interval_ns = time_s_to_ns(1.0f / 60.0f);

src/xrt/include/xrt/xrt_device.h

···
 // Copyright 2019-2024, Collabora, Ltd.
+// Copyright 2024-2025, NVIDIA CORPORATION.
 // SPDX-License-Identifier: BSL-1.0
 /*!
  * @file
···
 };
 
 /*!
+ * Static data of supported features of the @ref xrt_device this struct sits on.
+ *
+ * This struct needs to always be a piece of data as it sits inside of the
+ * shared memory area in the IPC layer, so no pointers please.
+ *
+ * @ingroup xrt_iface
+ */
+struct xrt_device_supported
+{
+	bool orientation_tracking;
+	bool position_tracking;
+	bool hand_tracking;
+	bool eye_gaze;
+	bool force_feedback;
+	bool ref_space_usage;
+	bool form_factor_check;
+	bool stage;
+	bool face_tracking;
+	bool body_tracking;
+	bool battery_status;
+
+	bool planes;
+	enum xrt_plane_detection_capability_flags_ext plane_capability_flags;
+};
+
+/*!
  * @interface xrt_device
  *
  * A single HMD or input device.
···
 	//! Array of output structs.
 	struct xrt_output *outputs;
 
-	bool orientation_tracking_supported;
-	bool position_tracking_supported;
-	bool hand_tracking_supported;
-	bool eye_gaze_supported;
-	bool force_feedback_supported;
-	bool ref_space_usage_supported;
-	bool form_factor_check_supported;
-	bool stage_supported;
-	bool face_tracking_supported;
-	bool body_tracking_supported;
-	bool battery_status_supported;
-	bool planes_supported;
-	enum xrt_plane_detection_capability_flags_ext plane_capability_flags;
+	//! What features/functions/things does this device supports?
+	struct xrt_device_supported supported;
+
 
 	/*
 	 *

src/xrt/ipc/client/ipc_client_device.c

···
 	u_var_add_root(icd, icd->base.str, true);
 	u_var_add_ro_u32(icd, &icd->device_id, "device_id");
 
-	icd->base.orientation_tracking_supported = isdev->orientation_tracking_supported;
-	icd->base.position_tracking_supported = isdev->position_tracking_supported;
-	icd->base.hand_tracking_supported = isdev->hand_tracking_supported;
-	icd->base.eye_gaze_supported = isdev->eye_gaze_supported;
-	icd->base.face_tracking_supported = isdev->face_tracking_supported;
-	icd->base.body_tracking_supported = isdev->body_tracking_supported;
-	icd->base.force_feedback_supported = isdev->force_feedback_supported;
-	icd->base.stage_supported = isdev->stage_supported;
-	icd->base.planes_supported = isdev->planes_supported;
-	icd->base.plane_capability_flags = isdev->plane_capability_flags;
+	// Copy information.
+	icd->base.device_type = isdev->device_type;
+	icd->base.supported = isdev->supported;
 
-	icd->base.device_type = isdev->device_type;
 	return &icd->base;
 }

src/xrt/ipc/client/ipc_client_hmd.c

···
 	u_var_add_root(ich, ich->base.str, true);
 	u_var_add_ro_u32(ich, &ich->device_id, "device_id");
 
-	ich->base.orientation_tracking_supported = isdev->orientation_tracking_supported;
-	ich->base.position_tracking_supported = isdev->position_tracking_supported;
+	// Copy information.
 	ich->base.device_type = isdev->device_type;
-	ich->base.hand_tracking_supported = isdev->hand_tracking_supported;
-	ich->base.eye_gaze_supported = isdev->eye_gaze_supported;
-	ich->base.face_tracking_supported = isdev->face_tracking_supported;
-	ich->base.body_tracking_supported = isdev->body_tracking_supported;
-	ich->base.force_feedback_supported = isdev->force_feedback_supported;
-	ich->base.form_factor_check_supported = isdev->form_factor_check_supported;
-	ich->base.stage_supported = isdev->stage_supported;
-	ich->base.battery_status_supported = isdev->battery_status_supported;
-	ich->base.planes_supported = isdev->planes_supported;
-	ich->base.plane_capability_flags = isdev->plane_capability_flags;
+	ich->base.supported = isdev->supported;
 
 	return &ich->base;
 }

src/xrt/ipc/server/ipc_server_process.c

···
 		memcpy(isdev->str, xdev->str, sizeof(isdev->str));
 		memcpy(isdev->serial, xdev->serial, sizeof(isdev->serial));
 
-		isdev->orientation_tracking_supported = xdev->orientation_tracking_supported;
-		isdev->position_tracking_supported = xdev->position_tracking_supported;
+		// Copy information.
 		isdev->device_type = xdev->device_type;
-		isdev->hand_tracking_supported = xdev->hand_tracking_supported;
-		isdev->force_feedback_supported = xdev->force_feedback_supported;
-		isdev->form_factor_check_supported = xdev->form_factor_check_supported;
-		isdev->eye_gaze_supported = xdev->eye_gaze_supported;
-		isdev->face_tracking_supported = xdev->face_tracking_supported;
-		isdev->body_tracking_supported = xdev->body_tracking_supported;
-		isdev->stage_supported = xdev->stage_supported;
-		isdev->battery_status_supported = xdev->battery_status_supported;
-		isdev->planes_supported = xdev->planes_supported;
-		isdev->plane_capability_flags = xdev->plane_capability_flags;
+		isdev->supported = xdev->supported;
 
 		// Setup the tracking origin.
 		isdev->tracking_origin_index = (uint32_t)-1;

src/xrt/ipc/shared/ipc_protocol.h

···
 	//! 'Offset' into the array of outputs where the outputs starts.
 	uint32_t first_output_index;
 
-	bool orientation_tracking_supported;
-	bool position_tracking_supported;
-	bool hand_tracking_supported;
-	bool eye_gaze_supported;
-	bool face_tracking_supported;
-	bool body_tracking_supported;
-	bool force_feedback_supported;
-	bool form_factor_check_supported;
-	bool stage_supported;
-	bool battery_status_supported;
-	bool planes_supported;
-	enum xrt_plane_detection_capability_flags_ext plane_capability_flags;
+	//! The supported fields.
+	struct xrt_device_supported supported;
 };
 
 static_assert(sizeof(struct ipc_shared_device) == 564,

src/xrt/state_trackers/oxr/oxr_api_session.c

···
 	}
 
 	// Find the correct input on the device.
-	if (xdev != NULL && xdev->hand_tracking_supported) {
+	if (xdev != NULL && xdev->supported.hand_tracking) {
 		for (uint32_t j = 0; j < xdev->input_count; j++) {
 			struct xrt_input *input = &xdev->inputs[j];
 
···
 
 	//! @todo support planes on other devices
 	struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, head);
-	if (!xdev->planes_supported) {
+	if (!xdev->supported.planes) {
 		return XR_ERROR_FEATURE_UNSUPPORTED;
 	}
 
···
 		return oxr_error(&log, XR_ERROR_TIME_INVALID, "Time %" PRId64 " invalid", beginInfo->time);
 	}
 
-	if (!pd->xdev->planes_supported) {
+	if (!pd->xdev->supported.planes) {
 		return XR_ERROR_FEATURE_UNSUPPORTED;
 	}
 
···
 		return oxr_error(&log, XR_ERROR_TIME_INVALID, "Time %" PRId64 " invalid", info->time);
 	}
 
-	if (!pd->xdev->planes_supported) {
+	if (!pd->xdev->supported.planes) {
 		return XR_ERROR_FEATURE_UNSUPPORTED;
 	}
 

src/xrt/state_trackers/oxr/oxr_body_tracking.c

···
 	}
 
 	struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, body);
-	if (xdev == NULL || !xdev->body_tracking_supported) {
+	if (xdev == NULL || !xdev->supported.body_tracking) {
 		return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for body tracking role");
 	}
 
···
                          XrBodySkeletonFB *skeleton)
 {
 
-	if (body_tracker_fb->xdev == NULL || !body_tracker_fb->xdev->body_tracking_supported) {
+	if (body_tracker_fb->xdev == NULL || !body_tracker_fb->xdev->supported.body_tracking) {
 		return oxr_error(log, XR_ERROR_FUNCTION_UNSUPPORTED,
 		                 "Device not found or does not support body tracking.");
 	}
···
                           const XrBodyJointsLocateInfoFB *locateInfo,
                           XrBodyJointLocationsFB *locations)
 {
-	if (body_tracker_fb->xdev == NULL || !body_tracker_fb->xdev->body_tracking_supported) {
+	if (body_tracker_fb->xdev == NULL || !body_tracker_fb->xdev->supported.body_tracking) {
 		return oxr_error(log, XR_ERROR_FUNCTION_UNSUPPORTED,
 		                 "Device not found or does not support body tracking.");
 	}

src/xrt/state_trackers/oxr/oxr_face_tracking.c

···
 		return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for face tracking role");
 	}
 
-	if (!xdev->face_tracking_supported) {
+	if (!xdev->supported.face_tracking) {
 		return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "Device does not support HTC facial tracking");
 	}
 

src/xrt/state_trackers/oxr/oxr_face_tracking2_fb.c

···
 		return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for face tracking role");
 	}
 
-	if (!xdev->face_tracking_supported || xdev->get_face_tracking == NULL) {
+	if (!xdev->supported.face_tracking || xdev->get_face_tracking == NULL) {
 		return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "Device does not support FB2 face tracking");
 	}
 

src/xrt/state_trackers/oxr/oxr_system.c

···
 	}
 
 	struct xrt_device *xdev = GET_XDEV_BY_ROLE(selected, head);
-	if (xdev->form_factor_check_supported &&
+	if (xdev->supported.form_factor_check &&
 	    !xrt_device_is_form_factor_available(xdev, convert_form_factor(form_factor))) {
 		return oxr_error(log, XR_ERROR_FORM_FACTOR_UNAVAILABLE, "request form factor %i is unavailable now",
 		                 form_factor);
···
 	struct xrt_device *ht_left = GET_XDEV_BY_ROLE(sys, hand_tracking_left);
 	struct xrt_device *ht_right = GET_XDEV_BY_ROLE(sys, hand_tracking_right);
 
-	bool left_supported = ht_left && ht_left->hand_tracking_supported;
-	bool right_supported = ht_right && ht_right->hand_tracking_supported;
+	bool left_supported = ht_left && ht_left->supported.hand_tracking;
+	bool right_supported = ht_right && ht_right->supported.hand_tracking;
 
 	return left_supported || right_supported;
 }
···
 	struct oxr_system *sys = &inst->system;
 	struct xrt_device *eyes = GET_XDEV_BY_ROLE(sys, eyes);
 
-	return eyes && eyes->eye_gaze_supported;
+	return eyes && eyes->supported.eye_gaze;
 }
 
 bool
···
 	struct xrt_device *ffb_left = GET_XDEV_BY_ROLE(sys, hand_tracking_left);
 	struct xrt_device *ffb_right = GET_XDEV_BY_ROLE(sys, hand_tracking_right);
 
-	bool left_supported = ffb_left && ffb_left->force_feedback_supported;
-	bool right_supported = ffb_right && ffb_right->force_feedback_supported;
+	bool left_supported = ffb_left && ffb_left->supported.force_feedback;
+	bool right_supported = ffb_right && ffb_right->supported.force_feedback;
 
 	return left_supported || right_supported;
 }
···
 	if (supports_lip)
 		*supports_lip = false;
 
-	if (face_xdev == NULL || !face_xdev->face_tracking_supported || face_xdev->inputs == NULL) {
+	if (face_xdev == NULL || !face_xdev->supported.face_tracking || face_xdev->inputs == NULL) {
 		return;
 	}
 
···
 	struct oxr_system *sys = &inst->system;
 	struct xrt_device *face_xdev = GET_XDEV_BY_ROLE(sys, face);
 
-	if (face_xdev == NULL || !face_xdev->face_tracking_supported || face_xdev->inputs == NULL) {
+	if (face_xdev == NULL || !face_xdev->supported.face_tracking || face_xdev->inputs == NULL) {
 		return;
 	}
 
···
 {
 	struct oxr_system *sys = &inst->system;
 	const struct xrt_device *body = GET_XDEV_BY_ROLE(sys, body);
-	if (body == NULL || !body->body_tracking_supported || body->inputs == NULL) {
+	if (body == NULL || !body->supported.body_tracking || body->inputs == NULL) {
 		return false;
 	}
 
···
 	}
 	properties->graphicsProperties.maxSwapchainImageWidth = 1024 * 16;
 	properties->graphicsProperties.maxSwapchainImageHeight = 1024 * 16;
-	properties->trackingProperties.orientationTracking = xdev->orientation_tracking_supported;
-	properties->trackingProperties.positionTracking = xdev->position_tracking_supported;
+	properties->trackingProperties.orientationTracking = xdev->supported.orientation_tracking;
+	properties->trackingProperties.positionTracking = xdev->supported.position_tracking;
 
 #ifdef OXR_HAVE_EXT_hand_tracking
 	XrSystemHandTrackingPropertiesEXT *hand_tracking_props = NULL;
···
 	if (plane_detection_props) {
 		// for now these are mapped 1:1
 		plane_detection_props->supportedFeatures =
-		    (XrPlaneDetectionCapabilityFlagsEXT)xdev->plane_capability_flags;
+		    (XrPlaneDetectionCapabilityFlagsEXT)xdev->supported.plane_capability_flags;
 	}
 #endif // OXR_HAVE_EXT_plane_detection
 

src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp

···
 
 			AddControl("/input/trackpad/y", XRT_INPUT_INDEX_TRACKPAD, &y);
 
-			if (m_xdev->hand_tracking_supported) {
+			if (m_xdev->supported.hand_tracking) {
 				ovrd_log("Enabling skeletal input as this device supports it");
 
 				// skeletal input compatibility with games is a bit funky with any controllers
···
 		m_pose.poseIsValid = false;
 		m_pose.deviceIsConnected = true;
 		m_pose.result = vr::TrackingResult_Uninitialized;
-		m_pose.willDriftInYaw = !m_xdev->position_tracking_supported;
+		m_pose.willDriftInYaw = !m_xdev->supported.position_tracking;
 
 		if (m_emulate_index_controller) {
 			m_input_profile = std::string("{indexcontroller}/input/index_controller_profile.json");
···
 			}
 		}
 
-		if (m_xdev->hand_tracking_supported && m_skeletal_input_control.control_handle) {
+		if (m_xdev->supported.hand_tracking && m_skeletal_input_control.control_handle) {
 			vr::VRBoneTransform_t bone_transforms[OPENVR_BONE_COUNT];
 
 			timepoint_ns now_ns = os_monotonic_get_ns();
···
 
 	    .result = vr::TrackingResult_Running_OK,
 	    .poseIsValid = (rel.relation_flags & XRT_SPACE_RELATION_ORIENTATION_VALID_BIT) != 0,
-	    .willDriftInYaw = !m_xdev->position_tracking_supported,
+	    .willDriftInYaw = !m_xdev->supported.position_tracking,
 	    //! @todo: Monado head model?
-	    .shouldApplyHeadModel = !m_xdev->position_tracking_supported,
+	    .shouldApplyHeadModel = !m_xdev->supported.position_tracking,
 	    .deviceIsConnected = true,
 	};
 	apply_pose(&rel, &t);

src/xrt/targets/common/target_builder_simulated.c

···
 
 	// Make the objects be tracked in space.
 	//! @todo Make these be a option to the hmd create function, or just make it be there from the start.
-	head->orientation_tracking_supported = true;
-	head->position_tracking_supported = true;
+	head->supported.orientation_tracking = true;
+	head->supported.position_tracking = true;
 	//! @todo Create a shared tracking origin on the system devices struct instead.
 	head->tracking_origin->type = XRT_TRACKING_TYPE_OTHER; // Just anything other then none.
 

src/xrt/targets/libmonado/monado.c

···
 	const struct ipc_shared_device *shared_device = &root->ipc_c.ism->isdevs[device_index];
 
 	switch (prop) {
-	case MND_PROPERTY_SUPPORTS_POSITION_BOOL: *out_bool = shared_device->position_tracking_supported; break;
-	case MND_PROPERTY_SUPPORTS_ORIENTATION_BOOL: *out_bool = shared_device->orientation_tracking_supported; break;
+	case MND_PROPERTY_SUPPORTS_POSITION_BOOL: *out_bool = shared_device->supported.position_tracking; break;
+	case MND_PROPERTY_SUPPORTS_ORIENTATION_BOOL: *out_bool = shared_device->supported.orientation_tracking; break;
 	default: PE("Is not a valid boolean property (%u)", prop); return MND_ERROR_INVALID_PROPERTY;
 	}
 
···
 
 	const struct ipc_shared_device *shared_device = &root->ipc_c.ism->isdevs[device_index];
 
-	if (!shared_device->battery_status_supported) {
+	if (!shared_device->supported.battery_status) {
 		return MND_ERROR_OPERATION_FAILED;
 	}