drivers: Use the new helper to set functions

This adds the helper to some of the drivers,
but not all that can be done as a follow up.

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

src/xrt/drivers/android/android_sensors.c

···
 
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_distortion_mesh.h"
 #include "util/u_var.h"
 #include "util/u_visibility_mask.h"
···
 	struct android_device *d = U_DEVICE_ALLOCATE(struct android_device, flags, 1, 0);
 
 	d->base.name = XRT_DEVICE_GENERIC_HMD;
-	d->base.destroy = android_device_destroy;
-	d->base.update_inputs = u_device_noop_update_inputs;
-	d->base.set_output = u_device_ni_set_output;
-	d->base.get_tracked_pose = android_device_get_tracked_pose;
+	u_device_populate_function_pointers(&d->base, android_device_get_tracked_pose, android_device_destroy);
 	d->base.get_view_poses = u_device_get_view_poses;
 	d->base.get_visibility_mask = u_device_get_visibility_mask;
 	d->base.compute_distortion = android_device_compute_distortion;

src/xrt/drivers/euroc/euroc_device.c

···
 #include "util/u_misc.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_distortion_mesh.h"
 #include "util/u_var.h"
 #include "math/m_space.h"
···
 		xd->inputs[0].name = XRT_INPUT_SIMPLE_GRIP_POSE;
 	}
 
-	xd->update_inputs = u_device_noop_update_inputs;
-	xd->get_tracked_pose = euroc_device_get_tracked_pose;
-	xd->destroy = euroc_device_destroy;
+	u_device_populate_function_pointers(xd, euroc_device_get_tracked_pose, euroc_device_destroy);
 	if (is_hmd) {
 		xd->get_view_poses = u_device_get_view_poses;
-	} else {
-		xd->get_view_poses = u_device_ni_get_view_poses;
 	}
 
 	u_var_add_root(ed, dev_name, false);

src/xrt/drivers/ht_ctrl_emu/ht_ctrl_emu.cpp

···
 #include "util/u_misc.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_distortion_mesh.h"
 #include "util/u_config_json.h"
 
···
 		cemud[i]->base.inputs[CEMU_INDEX_GRIP].name = XRT_INPUT_HAND_CTRL_EMU_GRIP_POSE;
 		cemud[i]->base.inputs[CEMU_INDEX_AIM].name = XRT_INPUT_HAND_CTRL_EMU_AIM_POSE;
 
+		u_device_populate_function_pointers(&cemud[i]->base, cemu_device_get_tracked_pose, cemu_device_destroy);
 		cemud[i]->base.update_inputs = cemu_device_update_inputs;
-		cemud[i]->base.get_tracked_pose = cemu_device_get_tracked_pose;
-		cemud[i]->base.set_output = u_device_ni_set_output;
 		cemud[i]->base.get_hand_tracking = cemu_device_get_hand_tracking;
-		cemud[i]->base.destroy = cemu_device_destroy;
 
 		cemud[i]->base.device_type =
 		    i ? XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER : XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER;

src/xrt/drivers/hydra/hydra_driver.c

···
 
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_misc.h"
 #include "util/u_time.h"
 #include "util/u_logging.h"
···
 	for (size_t i = 0; i < 2; ++i) {
 		struct hydra_device *hd = hs->devs[i];
 
-		hd->base.destroy = hydra_device_destroy;
+		u_device_populate_function_pointers(&hd->base, hydra_device_get_tracked_pose, hydra_device_destroy);
 		hd->base.update_inputs = hydra_device_update_inputs;
-		hd->base.get_tracked_pose = hydra_device_get_tracked_pose;
-		hd->base.set_output = u_device_ni_set_output;
 		hd->base.name = XRT_DEVICE_HYDRA;
 		snprintf(hd->base.str, XRT_DEVICE_NAME_LEN, "%s %i", "Razer Hydra Controller", (int)(i + 1));
 		snprintf(hd->base.serial, XRT_DEVICE_NAME_LEN, "%s%i", "RZRHDRC", (int)(i + 1));

src/xrt/drivers/ohmd/oh_device.c

···
 #include "util/u_misc.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_time.h"
 #include "util/u_distortion_mesh.h"
 #include "util/u_logging.h"
···
 
 	enum u_device_alloc_flags flags = U_DEVICE_ALLOC_HMD;
 	struct oh_device *ohd = U_DEVICE_ALLOCATE(struct oh_device, flags, 1, 0);
+	u_device_populate_function_pointers(&ohd->base, oh_device_get_tracked_pose, oh_device_destroy);
 	ohd->base.update_inputs = oh_device_update_inputs;
-	ohd->base.get_tracked_pose = oh_device_get_tracked_pose;
 	ohd->base.get_view_poses = u_device_get_view_poses;
-	ohd->base.destroy = oh_device_destroy;
 	ohd->base.inputs[0].name = XRT_INPUT_GENERIC_HEAD_POSE;
 	ohd->base.name = XRT_DEVICE_GENERIC_HMD;
 	ohd->ctx = ctx;
···
 
 	enum u_device_alloc_flags flags = 0;
 	struct oh_device *ohd = U_DEVICE_ALLOCATE(struct oh_device, flags, input_count, output_count);
+	u_device_populate_function_pointers(&ohd->base, oh_device_get_tracked_pose, oh_device_destroy);
 	ohd->base.update_inputs = oh_device_update_inputs;
 	ohd->base.set_output = oh_device_set_output;
-	ohd->base.get_tracked_pose = oh_device_get_tracked_pose;
-	ohd->base.get_view_poses = u_device_ni_get_view_poses;
-	ohd->base.destroy = oh_device_destroy;
 	if (oculus_touch) {
 		ohd->ohmd_device_type = OPENHMD_OCULUS_RIFT_CONTROLLER;
 		ohd->base.name = XRT_DEVICE_TOUCH_CONTROLLER;

src/xrt/drivers/realsense/rs_ddev.c

···
 
 #include "util/u_time.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_logging.h"
 
 #include "util/u_json.h"
···
 
 	U_LOG_D("Realsense opts are %i %i %i %i %i\n", rs->enable_mapping, rs->enable_pose_jumping,
 	        rs->enable_relocalization, rs->enable_pose_prediction, rs->enable_pose_filtering);
-	rs->base.update_inputs = u_device_noop_update_inputs;
-	rs->base.get_tracked_pose = rs_ddev_get_tracked_pose;
-	rs->base.get_view_poses = u_device_ni_get_view_poses;
-	rs->base.destroy = rs_ddev_destroy;
+	u_device_populate_function_pointers(&rs->base, rs_ddev_get_tracked_pose, rs_ddev_destroy);
 	rs->base.name = XRT_DEVICE_REALSENSE;
 	rs->base.tracking_origin->type = XRT_TRACKING_TYPE_EXTERNAL_SLAM;
 

src/xrt/drivers/remote/r_device.c

···
 #include "util/u_misc.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_hand_tracking.h"
 
 #include "vive/vive_bindings.h"
···
 	    struct r_device, flags, input_count, output_count);
 
 	// Setup the basics.
+	u_device_populate_function_pointers(&rd->base, r_device_get_tracked_pose, r_device_destroy);
 	rd->base.update_inputs = r_device_update_inputs;
-	rd->base.get_tracked_pose = r_device_get_tracked_pose;
 	rd->base.get_hand_tracking = r_device_get_hand_tracking;
-	rd->base.get_view_poses = u_device_ni_get_view_poses;
-	rd->base.set_output = u_device_ni_set_output;
-	rd->base.destroy = r_device_destroy;
 	rd->base.tracking_origin = &r->origin;
 	rd->base.supported.orientation_tracking = true;
 	rd->base.supported.position_tracking = true;

src/xrt/drivers/remote/r_hmd.c

···
 #include "util/u_misc.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_distortion_mesh.h"
 
 #include "math/m_api.h"
···
 	    struct r_hmd, flags, input_count, output_count);
 
 	// Setup the basics.
-	rh->base.update_inputs = u_device_noop_update_inputs;
-	rh->base.get_tracked_pose = r_hmd_get_tracked_pose;
-	rh->base.get_hand_tracking = u_device_ni_get_hand_tracking;
+	u_device_populate_function_pointers(&rh->base, r_hmd_get_tracked_pose, r_hmd_destroy);
 	rh->base.get_view_poses = r_hmd_get_view_poses;
-	rh->base.set_output = u_device_ni_set_output;
-	rh->base.destroy = r_hmd_destroy;
 	rh->base.tracking_origin = &r->origin;
 	rh->base.supported.orientation_tracking = true;
 	rh->base.supported.position_tracking = true;

src/xrt/drivers/rift_s/rift_s_controller.c

···
 #include "os/os_hid.h"
 
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_trace_marker.h"
 #include "util/u_var.h"
 
···
 
 	os_mutex_init(&ctrl->mutex);
 
+	u_device_populate_function_pointers(&ctrl->base, rift_s_controller_get_tracked_pose, rift_s_controller_destroy);
 	ctrl->base.update_inputs = rift_s_controller_update_inputs;
-	ctrl->base.set_output = u_device_ni_set_output;
-	ctrl->base.get_tracked_pose = rift_s_controller_get_tracked_pose;
 	ctrl->base.get_view_poses = u_device_get_view_poses;
-	ctrl->base.destroy = rift_s_controller_destroy;
 	ctrl->base.name = XRT_DEVICE_TOUCH_CONTROLLER;
 	ctrl->base.device_type = device_type;
 

src/xrt/drivers/simulated/simulated_controller.c

···
 #include "util/u_time.h"
 #include "util/u_debug.h"
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_logging.h"
 #include "util/u_distortion_mesh.h"
 
···
 
 	// Allocate.
 	struct simulated_device *sd = U_DEVICE_ALLOCATE(struct simulated_device, flags, input_count, output_count);
+	u_device_populate_function_pointers(&sd->base, simulated_device_get_tracked_pose, simulated_device_destroy);
 	sd->base.update_inputs = simulated_device_update_inputs;
-	sd->base.get_tracked_pose = simulated_device_get_tracked_pose;
-	sd->base.get_hand_tracking = u_device_ni_get_hand_tracking;
-	sd->base.get_view_poses = u_device_ni_get_view_poses;
-	sd->base.set_output = u_device_ni_set_output;
-	sd->base.destroy = simulated_device_destroy;
 	sd->base.tracking_origin = origin;
 	sd->base.supported.orientation_tracking = true;
 	sd->base.supported.position_tracking = true;

src/xrt/drivers/twrap/twrap_slam.c

···
 #include <assert.h>
 
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "math/m_space.h"
 #include "util/u_tracked_imu_3dof.h"
 
···
 
 
 
-	dx->base.update_inputs = u_device_noop_update_inputs;
-	dx->base.get_tracked_pose = twrap_slam_get_tracked_pose;
-	dx->base.get_view_poses = u_device_ni_get_view_poses;
-	dx->base.destroy = twrap_slam_destroy;
+	u_device_populate_function_pointers(&dx->base, twrap_slam_get_tracked_pose, twrap_slam_destroy);
 	dx->base.name = name;
 	dx->base.tracking_origin->type = XRT_TRACKING_TYPE_OTHER;
 	dx->base.inputs[0].name = XRT_INPUT_GENERIC_TRACKER_POSE;

src/xrt/drivers/wmr/wmr_controller_base.c

···
 wmr_controller_base_init(struct wmr_controller_base *wcb,
                          struct wmr_controller_connection *conn,
                          enum xrt_device_type controller_type,
-                         enum u_logging_level log_level)
+                         enum u_logging_level log_level,
+                         u_device_destroy_function_t destroy_fn)
 {
 	DRV_TRACE_MARKER();
 
···
 		snprintf(wcb->base.serial, XRT_DEVICE_NAME_LEN, "Right Controller");
 	}
 
-	wcb->base.get_tracked_pose = wmr_controller_base_get_tracked_pose;
+	// Set all functions.
+	u_device_populate_function_pointers(&wcb->base, wmr_controller_base_get_tracked_pose, destroy_fn);
 
 	wcb->base.name = XRT_DEVICE_WMR_CONTROLLER;
 	wcb->base.device_type = controller_type;

src/xrt/drivers/wmr/wmr_controller_base.h

···
 
 #include "os/os_threading.h"
 #include "math/m_imu_3dof.h"
+#include "util/u_device.h"
 #include "util/u_logging.h"
 #include "xrt/xrt_device.h"
 
···
 wmr_controller_base_init(struct wmr_controller_base *wcb,
                          struct wmr_controller_connection *conn,
                          enum xrt_device_type controller_type,
-                         enum u_logging_level log_level);
+                         enum u_logging_level log_level,
+                         u_device_destroy_function_t destroy_fn);
 
 void
 wmr_controller_base_deinit(struct wmr_controller_base *wcb);

src/xrt/drivers/wmr/wmr_controller_hp.c

···
 #include "math/m_api.h"
 
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_trace_marker.h"
 #include "util/u_var.h"
 
···
 	    U_DEVICE_ALLOCATE(struct wmr_controller_hp, flags, WMR_CONTROLLER_INDEX_COUNT, 1);
 	struct wmr_controller_base *wcb = (struct wmr_controller_base *)(ctrl);
 
-	if (!wmr_controller_base_init(wcb, conn, controller_type, log_level)) {
+	if (!wmr_controller_base_init(wcb, conn, controller_type, log_level, wmr_controller_hp_destroy)) {
 		wmr_controller_hp_destroy(&wcb->base);
 		return NULL;
 	}
 
 	wcb->handle_input_packet = handle_input_packet;
 
+	// Only set those we want to overwrite.
+	wcb->base.update_inputs = wmr_controller_hp_update_inputs;
 	wcb->base.name = XRT_DEVICE_HP_REVERB_G2_CONTROLLER;
 
 	if (controller_type == XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER) {
···
 	} else {
 		snprintf(wcb->base.str, ARRAY_SIZE(wcb->base.str), "HP Reverb G2 Right Controller");
 	}
-
-	wcb->base.destroy = wmr_controller_hp_destroy;
-	wcb->base.update_inputs = wmr_controller_hp_update_inputs;
-	wcb->base.set_output = u_device_ni_set_output;
 
 	SET_INPUT(wcb, MENU_CLICK, MENU_CLICK);
 	SET_INPUT(wcb, HOME_CLICK, HOME_CLICK);

src/xrt/drivers/wmr/wmr_controller_og.c

···
 #include "math/m_api.h"
 
 #include "util/u_device.h"
-#include "util/u_device_ni.h"
 #include "util/u_trace_marker.h"
 #include "util/u_var.h"
 
···
 	struct wmr_controller_og *ctrl = U_DEVICE_ALLOCATE(struct wmr_controller_og, flags, 11, 1);
 	struct wmr_controller_base *wcb = (struct wmr_controller_base *)(ctrl);
 
-	if (!wmr_controller_base_init(wcb, conn, controller_type, log_level)) {
+	if (!wmr_controller_base_init(wcb, conn, controller_type, log_level, wmr_controller_og_destroy)) {
 		wmr_controller_og_destroy(&wcb->base);
 		return NULL;
 	}
 
 	wcb->handle_input_packet = handle_input_packet;
 
+	// Only set those we want to overwrite.
+	wcb->base.update_inputs = wmr_controller_og_update_inputs;
+
 	if (pid == ODYSSEY_CONTROLLER_PID) {
 		wcb->base.name = XRT_DEVICE_SAMSUNG_ODYSSEY_CONTROLLER;
 	} else {
 		wcb->base.name = XRT_DEVICE_WMR_CONTROLLER;
 	}
-	wcb->base.destroy = wmr_controller_og_destroy;
-	wcb->base.update_inputs = wmr_controller_og_update_inputs;
-	wcb->base.set_output = u_device_ni_set_output;
 
 	if (pid == ODYSSEY_CONTROLLER_PID) {
 		SET_ODYSSEY_INPUT(wcb, MENU_CLICK);