Rework XR positional trackers

2 files changed, 430 insertions, 307 deletions

diff --git a/scene/3d/xr_nodes.cpp b/scene/3d/xr_nodes.cpp
index 56edf100f6..9dbee58f0e 100644
--- a/scene/3d/xr_nodes.cpp
+++ b/scene/3d/xr_nodes.cpp
@@ -47,13 +47,45 @@ void XRCamera3D::_notification(int p_what) {
 		case NOTIFICATION_EXIT_TREE: {
 			// need to find our XROrigin3D parent and let it know we're no longer its camera!
 			XROrigin3D *origin = Object::cast_to<XROrigin3D>(get_parent());
-			if (origin != nullptr) {
-				origin->clear_tracked_camera_if(this);
+			if (origin != nullptr && origin->get_tracked_camera() == this) {
+				origin->set_tracked_camera(nullptr);
 			}
 		}; break;
 	};
 };
 
+void XRCamera3D::_changed_tracker(const StringName p_tracker_name, int p_tracker_type) {
+	if (p_tracker_name == tracker_name) {
+		XRServer *xr_server = XRServer::get_singleton();
+		ERR_FAIL_NULL(xr_server);
+
+		tracker = xr_server->get_tracker(p_tracker_name);
+		if (tracker.is_valid()) {
+			tracker->connect("pose_changed", callable_mp(this, &XRCamera3D::_pose_changed));
+
+			Ref<XRPose> pose = tracker->get_pose(pose_name);
+			if (pose.is_valid()) {
+				set_transform(pose->get_adjusted_transform());
+			}
+		}
+	}
+}
+
+void XRCamera3D::_removed_tracker(const StringName p_tracker_name, int p_tracker_type) {
+	if (p_tracker_name == tracker_name) {
+		if (tracker.is_valid()) {
+			tracker->disconnect("pose_changed", callable_mp(this, &XRCamera3D::_pose_changed));
+		}
+		tracker.unref();
+	}
+}
+
+void XRCamera3D::_pose_changed(const Ref<XRPose> &p_pose) {
+	if (p_pose->get_name() == pose_name) {
+		set_transform(p_pose->get_adjusted_transform());
+	}
+}
+
 TypedArray<String> XRCamera3D::get_configuration_warnings() const {
 	TypedArray<String> warnings = Node::get_configuration_warnings();
 
@@ -172,195 +204,215 @@ Vector<Plane> XRCamera3D::get_frustum() const {
 	return cm.get_projection_planes(get_camera_transform());
 };
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
+XRCamera3D::XRCamera3D() {
+	XRServer *xr_server = XRServer::get_singleton();
+	ERR_FAIL_NULL(xr_server);
 
-void XRController3D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			set_process_internal(true);
-		}; break;
-		case NOTIFICATION_EXIT_TREE: {
-			set_process_internal(false);
-		}; break;
-		case NOTIFICATION_INTERNAL_PROCESS: {
-			// get our XRServer
-			XRServer *xr_server = XRServer::get_singleton();
-			ERR_FAIL_NULL(xr_server);
-
-			// find the tracker for our controller
-			Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
-			if (!tracker.is_valid()) {
-				// this controller is currently turned off
-				is_active = false;
-				button_states = 0;
-			} else {
-				is_active = true;
-				set_transform(tracker->get_transform(true));
-
-				int joy_id = tracker->get_joy_id();
-				if (joy_id >= 0) {
-					int mask = 1;
-					// check button states
-					for (int i = 0; i < 16; i++) {
-						bool was_pressed = (button_states & mask) == mask;
-						bool is_pressed = Input::get_singleton()->is_joy_button_pressed(joy_id, (JoyButton)i);
-
-						if (!was_pressed && is_pressed) {
-							emit_signal(SNAME("button_pressed"), i);
-							button_states += mask;
-						} else if (was_pressed && !is_pressed) {
-							emit_signal(SNAME("button_released"), i);
-							button_states -= mask;
-						};
-
-						mask = mask << 1;
-					};
-
-				} else {
-					button_states = 0;
-				};
-
-				// check for an updated mesh
-				Ref<Mesh> trackerMesh = tracker->get_mesh();
-				if (mesh != trackerMesh) {
-					mesh = trackerMesh;
-					emit_signal(SNAME("mesh_updated"), mesh);
-				}
-			};
-		}; break;
-		default:
-			break;
-	};
-};
+	xr_server->connect("tracker_added", callable_mp(this, &XRCamera3D::_changed_tracker));
+	xr_server->connect("tracker_updated", callable_mp(this, &XRCamera3D::_changed_tracker));
+	xr_server->connect("tracker_removed", callable_mp(this, &XRCamera3D::_removed_tracker));
+}
 
-void XRController3D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_controller_id", "controller_id"), &XRController3D::set_controller_id);
-	ClassDB::bind_method(D_METHOD("get_controller_id"), &XRController3D::get_controller_id);
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "controller_id", PROPERTY_HINT_RANGE, "0,32,1"), "set_controller_id", "get_controller_id");
-	ClassDB::bind_method(D_METHOD("get_controller_name"), &XRController3D::get_controller_name);
+XRCamera3D::~XRCamera3D() {
+	XRServer *xr_server = XRServer::get_singleton();
+	ERR_FAIL_NULL(xr_server);
 
-	// passthroughs to information about our related joystick
-	ClassDB::bind_method(D_METHOD("get_joystick_id"), &XRController3D::get_joystick_id);
-	ClassDB::bind_method(D_METHOD("is_button_pressed", "button"), &XRController3D::is_button_pressed);
-	ClassDB::bind_method(D_METHOD("get_joystick_axis", "axis"), &XRController3D::get_joystick_axis);
+	xr_server->disconnect("tracker_added", callable_mp(this, &XRCamera3D::_changed_tracker));
+	xr_server->disconnect("tracker_updated", callable_mp(this, &XRCamera3D::_changed_tracker));
+	xr_server->disconnect("tracker_removed", callable_mp(this, &XRCamera3D::_removed_tracker));
+}
 
-	ClassDB::bind_method(D_METHOD("get_is_active"), &XRController3D::get_is_active);
-	ClassDB::bind_method(D_METHOD("get_tracker_hand"), &XRController3D::get_tracker_hand);
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// XRNode3D is a node that has it's transform updated by an XRPositionalTracker.
+// Note that trackers are only available in runtime and only after an XRInterface registers one.
+// So we bind by name and as long as a tracker isn't available, our node remains inactive.
 
-	ClassDB::bind_method(D_METHOD("get_rumble"), &XRController3D::get_rumble);
-	ClassDB::bind_method(D_METHOD("set_rumble", "rumble"), &XRController3D::set_rumble);
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rumble", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"), "set_rumble", "get_rumble");
-	ADD_PROPERTY_DEFAULT("rumble", 0.0);
+void XRNode3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_tracker", "tracker_name"), &XRNode3D::set_tracker);
+	ClassDB::bind_method(D_METHOD("get_tracker"), &XRNode3D::get_tracker);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "tracker", PROPERTY_HINT_ENUM_SUGGESTION), "set_tracker", "get_tracker");
 
-	ClassDB::bind_method(D_METHOD("get_mesh"), &XRController3D::get_mesh);
+	ClassDB::bind_method(D_METHOD("set_pose_name", "pose"), &XRNode3D::set_pose_name);
+	ClassDB::bind_method(D_METHOD("get_pose_name"), &XRNode3D::get_pose_name);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "pose", PROPERTY_HINT_ENUM_SUGGESTION), "set_pose_name", "get_pose_name");
 
-	ADD_SIGNAL(MethodInfo("button_pressed", PropertyInfo(Variant::INT, "button")));
-	ADD_SIGNAL(MethodInfo("button_released", PropertyInfo(Variant::INT, "button")));
-	ADD_SIGNAL(MethodInfo("mesh_updated", PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh")));
+	ClassDB::bind_method(D_METHOD("get_is_active"), &XRNode3D::get_is_active);
+	ClassDB::bind_method(D_METHOD("get_has_tracking_data"), &XRNode3D::get_has_tracking_data);
+	ClassDB::bind_method(D_METHOD("get_pose"), &XRNode3D::get_pose);
+	ClassDB::bind_method(D_METHOD("trigger_haptic_pulse", "action_name", "frequency", "amplitude", "duration_sec", "delay_sec"), &XRNode3D::trigger_haptic_pulse);
 };
 
-void XRController3D::set_controller_id(int p_controller_id) {
-	// We don't check any bounds here, this controller may not yet be active and just be a place holder until it is.
-	// Note that setting this to 0 means this node is not bound to a controller yet.
-	controller_id = p_controller_id;
-	update_configuration_warnings();
-};
+void XRNode3D::_validate_property(PropertyInfo &property) const {
+	XRServer *xr_server = XRServer::get_singleton();
+	ERR_FAIL_NULL(xr_server);
 
-int XRController3D::get_controller_id() const {
-	return controller_id;
-};
+	if (property.name == "tracker") {
+		PackedStringArray names = xr_server->get_suggested_tracker_names();
+		String hint_string;
+		for (const String &name : names) {
+			hint_string += name + ",";
+		}
+		property.hint_string = hint_string;
+	} else if (property.name == "pose") {
+		PackedStringArray names = xr_server->get_suggested_pose_names(tracker_name);
+		String hint_string;
+		for (const String &name : names) {
+			hint_string += name + ",";
+		}
+		property.hint_string = hint_string;
+	}
+}
 
-String XRController3D::get_controller_name() const {
-	// get our XRServer
-	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, String());
+void XRNode3D::set_tracker(const StringName p_tracker_name) {
+	if (tracker.is_valid() && tracker->get_tracker_name() == p_tracker_name) {
+		// didn't change
+		return;
+	}
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
-	if (!tracker.is_valid()) {
-		return String("Not connected");
-	};
+	// just in case
+	_unbind_tracker();
 
-	return tracker->get_tracker_name();
-};
+	// copy the name
+	tracker_name = p_tracker_name;
+	pose_name = "default";
 
-int XRController3D::get_joystick_id() const {
-	// get our XRServer
-	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, 0);
+	// see if it's already available
+	_bind_tracker();
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
-	if (!tracker.is_valid()) {
-		// No tracker? no joystick id... (0 is our first joystick)
-		return -1;
-	};
+	update_configuration_warnings();
+	notify_property_list_changed();
+}
 
-	return tracker->get_joy_id();
-};
+StringName XRNode3D::get_tracker() const {
+	return tracker_name;
+}
 
-bool XRController3D::is_button_pressed(int p_button) const {
-	int joy_id = get_joystick_id();
-	if (joy_id == -1) {
-		return false;
-	};
+void XRNode3D::set_pose_name(const StringName p_pose_name) {
+	pose_name = p_pose_name;
 
-	return Input::get_singleton()->is_joy_button_pressed(joy_id, (JoyButton)p_button);
-};
+	// Update pose if we are bound to a tracker with a valid pose
+	Ref<XRPose> pose = get_pose();
+	if (pose.is_valid()) {
+		set_transform(pose->get_adjusted_transform());
+	}
+}
 
-float XRController3D::get_joystick_axis(int p_axis) const {
-	int joy_id = get_joystick_id();
-	if (joy_id == -1) {
-		return 0.0;
-	};
+StringName XRNode3D::get_pose_name() const {
+	return pose_name;
+}
 
-	return Input::get_singleton()->get_joy_axis(joy_id, (JoyAxis)p_axis);
-};
+bool XRNode3D::get_is_active() const {
+	if (tracker.is_null()) {
+		return false;
+	} else if (!tracker->has_pose(pose_name)) {
+		return false;
+	} else {
+		return true;
+	}
+}
 
-real_t XRController3D::get_rumble() const {
-	// get our XRServer
+bool XRNode3D::get_has_tracking_data() const {
+	if (tracker.is_null()) {
+		return false;
+	} else if (!tracker->has_pose(pose_name)) {
+		return false;
+	} else {
+		return tracker->get_pose(pose_name)->get_has_tracking_data();
+	}
+}
+
+void XRNode3D::trigger_haptic_pulse(const String &p_action_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec) {
+	// TODO need to link trackers to the interface that registered them so we can call this on the correct interface.
+	// For now this works fine as in 99% of the cases we only have our primary interface active
 	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, 0.0);
+	if (xr_server != nullptr) {
+		Ref<XRInterface> xr_interface = xr_server->get_primary_interface();
+		if (xr_interface.is_valid()) {
+			xr_interface->trigger_haptic_pulse(p_action_name, tracker_name, p_frequency, p_amplitude, p_duration_sec, p_delay_sec);
+		}
+	}
+}
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
-	if (!tracker.is_valid()) {
-		return 0.0;
-	};
+Ref<XRPose> XRNode3D::get_pose() {
+	if (tracker.is_valid()) {
+		return tracker->get_pose(pose_name);
+	} else {
+		return Ref<XRPose>();
+	}
+}
 
-	return tracker->get_rumble();
-};
+void XRNode3D::_bind_tracker() {
+	ERR_FAIL_COND_MSG(tracker.is_valid(), "Unbind the current tracker first");
 
-void XRController3D::set_rumble(real_t p_rumble) {
-	// get our XRServer
 	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL(xr_server);
+	if (xr_server != nullptr) {
+		tracker = xr_server->get_tracker(tracker_name);
+		if (tracker.is_null()) {
+			// It is possible and valid if the tracker isn't available (yet), in this case we just exit
+			return;
+		}
+
+		tracker->connect("pose_changed", callable_mp(this, &XRNode3D::_pose_changed));
+
+		Ref<XRPose> pose = get_pose();
+		if (pose.is_valid()) {
+			set_transform(pose->get_adjusted_transform());
+		}
+	}
+}
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
+void XRNode3D::_unbind_tracker() {
 	if (tracker.is_valid()) {
-		tracker->set_rumble(p_rumble);
-	};
-};
+		tracker->disconnect("pose_changed", callable_mp(this, &XRNode3D::_pose_changed));
 
-Ref<Mesh> XRController3D::get_mesh() const {
-	return mesh;
+		tracker.unref();
+	}
 }
 
-bool XRController3D::get_is_active() const {
-	return is_active;
-};
+void XRNode3D::_changed_tracker(const StringName p_tracker_name, int p_tracker_type) {
+	if (p_tracker_name == p_tracker_name) {
+		// just in case unref our current tracker
+		_unbind_tracker();
 
-XRPositionalTracker::TrackerHand XRController3D::get_tracker_hand() const {
-	// get our XRServer
+		// get our new tracker
+		_bind_tracker();
+	}
+}
+
+void XRNode3D::_removed_tracker(const StringName p_tracker_name, int p_tracker_type) {
+	if (p_tracker_name == p_tracker_name) {
+		// unref our tracker, it's no longer available
+		_unbind_tracker();
+	}
+}
+
+void XRNode3D::_pose_changed(const Ref<XRPose> &p_pose) {
+	if (p_pose.is_valid() && p_pose->get_name() == pose_name) {
+		set_transform(p_pose->get_adjusted_transform());
+	}
+}
+
+XRNode3D::XRNode3D() {
 	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, XRPositionalTracker::TRACKER_HAND_UNKNOWN);
+	ERR_FAIL_NULL(xr_server);
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, controller_id);
-	if (!tracker.is_valid()) {
-		return XRPositionalTracker::TRACKER_HAND_UNKNOWN;
-	};
+	xr_server->connect("tracker_added", callable_mp(this, &XRNode3D::_changed_tracker));
+	xr_server->connect("tracker_updated", callable_mp(this, &XRNode3D::_changed_tracker));
+	xr_server->connect("tracker_removed", callable_mp(this, &XRNode3D::_removed_tracker));
+}
 
-	return tracker->get_tracker_hand();
-};
+XRNode3D::~XRNode3D() {
+	_unbind_tracker();
+
+	XRServer *xr_server = XRServer::get_singleton();
+	ERR_FAIL_NULL(xr_server);
+
+	xr_server->disconnect("tracker_added", callable_mp(this, &XRNode3D::_changed_tracker));
+	xr_server->disconnect("tracker_updated", callable_mp(this, &XRNode3D::_changed_tracker));
+	xr_server->disconnect("tracker_removed", callable_mp(this, &XRNode3D::_removed_tracker));
+}
 
-TypedArray<String> XRController3D::get_configuration_warnings() const {
+TypedArray<String> XRNode3D::get_configuration_warnings() const {
 	TypedArray<String> warnings = Node::get_configuration_warnings();
 
 	if (is_visible() && is_inside_tree()) {
@@ -370,130 +422,171 @@ TypedArray<String> XRController3D::get_configuration_warnings() const {
 			warnings.push_back(TTR("XRController3D must have an XROrigin3D node as its parent."));
 		}
 
-		if (controller_id == 0) {
-			warnings.push_back(TTR("The controller ID must not be 0 or this controller won't be bound to an actual controller."));
+		if (tracker_name == "") {
+			warnings.push_back(TTR("No tracker name is set."));
+		}
+
+		if (pose_name == "") {
+			warnings.push_back(TTR("No pose is set."));
 		}
 	}
 
 	return warnings;
-};
+}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void XRAnchor3D::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			set_process_internal(true);
-		}; break;
-		case NOTIFICATION_EXIT_TREE: {
-			set_process_internal(false);
-		}; break;
-		case NOTIFICATION_INTERNAL_PROCESS: {
-			// get our XRServer
-			XRServer *xr_server = XRServer::get_singleton();
-			ERR_FAIL_NULL(xr_server);
-
-			// find the tracker for our anchor
-			Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_ANCHOR, anchor_id);
-			if (!tracker.is_valid()) {
-				// this anchor is currently not available
-				is_active = false;
-			} else {
-				is_active = true;
-				Transform3D transform;
-
-				// we'll need our world_scale
-				real_t world_scale = xr_server->get_world_scale();
-
-				// get our info from our tracker
-				transform.basis = tracker->get_orientation();
-				transform.origin = tracker->get_position(); // <-- already adjusted to world scale
-
-				// our basis is scaled to the size of the plane the anchor is tracking
-				// extract the size from our basis and reset the scale
-				size = transform.basis.get_scale() * world_scale;
-				transform.basis.orthonormalize();
-
-				// apply our reference frame and set our transform
-				set_transform(xr_server->get_reference_frame() * transform);
-
-				// check for an updated mesh
-				Ref<Mesh> trackerMesh = tracker->get_mesh();
-				if (mesh != trackerMesh) {
-					mesh = trackerMesh;
-					emit_signal(SNAME("mesh_updated"), mesh);
-				}
-			};
-		}; break;
-		default:
-			break;
-	};
-};
-
-void XRAnchor3D::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_anchor_id", "anchor_id"), &XRAnchor3D::set_anchor_id);
-	ClassDB::bind_method(D_METHOD("get_anchor_id"), &XRAnchor3D::get_anchor_id);
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "anchor_id", PROPERTY_HINT_RANGE, "0,32,1"), "set_anchor_id", "get_anchor_id");
-	ClassDB::bind_method(D_METHOD("get_anchor_name"), &XRAnchor3D::get_anchor_name);
+void XRController3D::_bind_methods() {
+	// passthroughs to information about our related joystick
+	ClassDB::bind_method(D_METHOD("is_button_pressed", "name"), &XRController3D::is_button_pressed);
+	ClassDB::bind_method(D_METHOD("get_value", "name"), &XRController3D::get_value);
+	ClassDB::bind_method(D_METHOD("get_axis", "name"), &XRController3D::get_axis);
 
-	ClassDB::bind_method(D_METHOD("get_is_active"), &XRAnchor3D::get_is_active);
-	ClassDB::bind_method(D_METHOD("get_size"), &XRAnchor3D::get_size);
+	ClassDB::bind_method(D_METHOD("get_tracker_hand"), &XRController3D::get_tracker_hand);
 
-	ClassDB::bind_method(D_METHOD("get_plane"), &XRAnchor3D::get_plane);
+	ClassDB::bind_method(D_METHOD("get_rumble"), &XRController3D::get_rumble);
+	ClassDB::bind_method(D_METHOD("set_rumble", "rumble"), &XRController3D::set_rumble);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rumble", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"), "set_rumble", "get_rumble");
+	ADD_PROPERTY_DEFAULT("rumble", 0.0);
 
-	ClassDB::bind_method(D_METHOD("get_mesh"), &XRAnchor3D::get_mesh);
-	ADD_SIGNAL(MethodInfo("mesh_updated", PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh")));
+	ADD_SIGNAL(MethodInfo("button_pressed", PropertyInfo(Variant::STRING, "name")));
+	ADD_SIGNAL(MethodInfo("button_released", PropertyInfo(Variant::STRING, "name")));
+	ADD_SIGNAL(MethodInfo("input_value_changed", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::FLOAT, "value")));
+	ADD_SIGNAL(MethodInfo("input_axis_changed", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::VECTOR2, "value")));
 };
 
-void XRAnchor3D::set_anchor_id(int p_anchor_id) {
-	// We don't check any bounds here, this anchor may not yet be active and just be a place holder until it is.
-	// Note that setting this to 0 means this node is not bound to an anchor yet.
-	anchor_id = p_anchor_id;
-	update_configuration_warnings();
-};
+void XRController3D::_bind_tracker() {
+	XRNode3D::_bind_tracker();
+	if (tracker.is_valid()) {
+		// bind to input signals
+		tracker->connect("button_pressed", callable_mp(this, &XRController3D::_button_pressed));
+		tracker->connect("button_released", callable_mp(this, &XRController3D::_button_released));
+		tracker->connect("input_value_changed", callable_mp(this, &XRController3D::_input_value_changed));
+		tracker->connect("input_axis_changed", callable_mp(this, &XRController3D::_input_axis_changed));
+	}
+}
 
-int XRAnchor3D::get_anchor_id() const {
-	return anchor_id;
-};
+void XRController3D::_unbind_tracker() {
+	if (tracker.is_valid()) {
+		// unbind input signals
+		tracker->disconnect("button_pressed", callable_mp(this, &XRController3D::_button_pressed));
+		tracker->disconnect("button_released", callable_mp(this, &XRController3D::_button_released));
+		tracker->disconnect("input_value_changed", callable_mp(this, &XRController3D::_input_value_changed));
+		tracker->disconnect("input_axis_changed", callable_mp(this, &XRController3D::_input_axis_changed));
+	}
 
-Vector3 XRAnchor3D::get_size() const {
-	return size;
-};
+	XRNode3D::_unbind_tracker();
+}
 
-String XRAnchor3D::get_anchor_name() const {
-	// get our XRServer
-	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, String());
+void XRController3D::_button_pressed(const String &p_name) {
+	// just pass it on...
+	emit_signal("button_pressed", p_name);
+}
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_ANCHOR, anchor_id);
-	if (!tracker.is_valid()) {
-		return String("Not connected");
-	};
+void XRController3D::_button_released(const String &p_name) {
+	// just pass it on...
+	emit_signal("button_released", p_name);
+}
 
-	return tracker->get_tracker_name();
-};
+void XRController3D::_input_value_changed(const String &p_name, float p_value) {
+	// just pass it on...
+	emit_signal("input_value_changed", p_name, p_value);
+}
 
-bool XRAnchor3D::get_is_active() const {
-	return is_active;
-};
+void XRController3D::_input_axis_changed(const String &p_name, Vector2 p_value) {
+	// just pass it on...
+	emit_signal("input_axis_changed", p_name, p_value);
+}
 
-TypedArray<String> XRAnchor3D::get_configuration_warnings() const {
-	TypedArray<String> warnings = Node::get_configuration_warnings();
+bool XRController3D::is_button_pressed(const StringName &p_name) const {
+	if (tracker.is_valid()) {
+		// Inputs should already be of the correct type, our XR runtime handles conversions between raw input and the desired type
+		bool pressed = tracker->get_input(p_name);
+		return pressed;
+	} else {
+		return false;
+	}
+}
 
-	if (is_visible() && is_inside_tree()) {
-		// must be child node of XROrigin3D!
-		XROrigin3D *origin = Object::cast_to<XROrigin3D>(get_parent());
-		if (origin == nullptr) {
-			warnings.push_back(TTR("XRAnchor3D must have an XROrigin3D node as its parent."));
-		}
+float XRController3D::get_value(const StringName &p_name) const {
+	if (tracker.is_valid()) {
+		// Inputs should already be of the correct type, our XR runtime handles conversions between raw input and the desired type, but just in case we convert
+		Variant input = tracker->get_input(p_name);
+		switch (input.get_type()) {
+			case Variant::BOOL: {
+				bool value = input;
+				return value ? 1.0 : 0.0;
+			} break;
+			case Variant::FLOAT: {
+				float value = input;
+				return value;
+			} break;
+			default:
+				return 0.0;
+		};
+	} else {
+		return 0.0;
+	}
+}
 
-		if (anchor_id == 0) {
-			warnings.push_back(TTR("The anchor ID must not be 0 or this anchor won't be bound to an actual anchor."));
+Vector2 XRController3D::get_axis(const StringName &p_name) const {
+	if (tracker.is_valid()) {
+		// Inputs should already be of the correct type, our XR runtime handles conversions between raw input and the desired type, but just in case we convert
+		Variant input = tracker->get_input(p_name);
+		switch (input.get_type()) {
+			case Variant::BOOL: {
+				bool value = input;
+				return Vector2(value ? 1.0 : 0.0, 0.0);
+			} break;
+			case Variant::FLOAT: {
+				float value = input;
+				return Vector2(value, 0.0);
+			} break;
+			case Variant::VECTOR2: {
+				Vector2 axis = input;
+				return axis;
+			}
+			default:
+				return Vector2();
 		}
+	} else {
+		return Vector2();
 	}
+}
 
-	return warnings;
-};
+real_t XRController3D::get_rumble() const {
+	if (!tracker.is_valid()) {
+		return 0.0;
+	}
+
+	return tracker->get_rumble();
+}
+
+void XRController3D::set_rumble(real_t p_rumble) {
+	if (tracker.is_valid()) {
+		tracker->set_rumble(p_rumble);
+	}
+}
+
+XRPositionalTracker::TrackerHand XRController3D::get_tracker_hand() const {
+	// get our XRServer
+	if (!tracker.is_valid()) {
+		return XRPositionalTracker::TRACKER_HAND_UNKNOWN;
+	}
+
+	return tracker->get_tracker_hand();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void XRAnchor3D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_size"), &XRAnchor3D::get_size);
+	ClassDB::bind_method(D_METHOD("get_plane"), &XRAnchor3D::get_plane);
+}
+
+Vector3 XRAnchor3D::get_size() const {
+	return size;
+}
 
 Plane XRAnchor3D::get_plane() const {
 	Vector3 location = get_position();
@@ -502,10 +595,6 @@ Plane XRAnchor3D::get_plane() const {
 	Plane plane(orientation.get_axis(1).normalized(), location);
 
 	return plane;
-};
-
-Ref<Mesh> XRAnchor3D::get_mesh() const {
-	return mesh;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -525,23 +614,21 @@ TypedArray<String> XROrigin3D::get_configuration_warnings() const {
 	}
 
 	return warnings;
-};
+}
 
 void XROrigin3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_world_scale", "world_scale"), &XROrigin3D::set_world_scale);
 	ClassDB::bind_method(D_METHOD("get_world_scale"), &XROrigin3D::get_world_scale);
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "world_scale"), "set_world_scale", "get_world_scale");
-};
+}
 
 void XROrigin3D::set_tracked_camera(XRCamera3D *p_tracked_camera) {
 	tracked_camera = p_tracked_camera;
-};
+}
 
-void XROrigin3D::clear_tracked_camera_if(XRCamera3D *p_tracked_camera) {
-	if (tracked_camera == p_tracked_camera) {
-		tracked_camera = nullptr;
-	};
-};
+XRCamera3D *XROrigin3D::get_tracked_camera() const {
+	return tracked_camera;
+}
 
 real_t XROrigin3D::get_world_scale() const {
 	// get our XRServer
@@ -549,7 +636,7 @@ real_t XROrigin3D::get_world_scale() const {
 	ERR_FAIL_NULL_V(xr_server, 1.0);
 
 	return xr_server->get_world_scale();
-};
+}
 
 void XROrigin3D::set_world_scale(real_t p_world_scale) {
 	// get our XRServer
@@ -557,7 +644,7 @@ void XROrigin3D::set_world_scale(real_t p_world_scale) {
 	ERR_FAIL_NULL(xr_server);
 
 	xr_server->set_world_scale(p_world_scale);
-};
+}
 
 void XROrigin3D::_notification(int p_what) {
 	// get our XRServer
@@ -596,4 +683,4 @@ void XROrigin3D::_notification(int p_what) {
 			interface->notification(p_what);
 		}
 	}
-};
+}
diff --git a/scene/3d/xr_nodes.h b/scene/3d/xr_nodes.h
index 6e54ff83d7..5e7d06093d 100644
--- a/scene/3d/xr_nodes.h
+++ b/scene/3d/xr_nodes.h
@@ -45,8 +45,18 @@ class XRCamera3D : public Camera3D {
 	GDCLASS(XRCamera3D, Camera3D);
 
 protected:
+	// The name and pose for our HMD tracker is currently the only hardcoded bit.
+	// If we ever are able to support multiple HMDs we may need to make this settable.
+	StringName tracker_name = "head";
+	StringName pose_name = "default";
+	Ref<XRPositionalTracker> tracker;
+
 	void _notification(int p_what);
 
+	void _changed_tracker(const StringName p_tracker_name, int p_tracker_type);
+	void _removed_tracker(const StringName p_tracker_name, int p_tracker_type);
+	void _pose_changed(const Ref<XRPose> &p_pose);
+
 public:
 	TypedArray<String> get_configuration_warnings() const override;
 
@@ -55,48 +65,88 @@ public:
 	virtual Vector3 project_position(const Point2 &p_point, real_t p_z_depth) const override;
 	virtual Vector<Plane> get_frustum() const override;
 
-	XRCamera3D() {}
-	~XRCamera3D() {}
+	XRCamera3D();
+	~XRCamera3D();
 };
 
 /*
-	XRController3D is a helper node that automatically updates its position based on tracker data.
+	XRNode3D is a helper node that implements binding to a tracker.
 
 	It must be a child node of our XROrigin node
 */
 
-class XRController3D : public Node3D {
-	GDCLASS(XRController3D, Node3D);
+class XRNode3D : public Node3D {
+	GDCLASS(XRNode3D, Node3D);
 
 private:
-	int controller_id = 1;
+	StringName tracker_name;
+	StringName pose_name = "default";
 	bool is_active = true;
-	int button_states = 0;
-	Ref<Mesh> mesh;
 
 protected:
-	void _notification(int p_what);
+	Ref<XRPositionalTracker> tracker;
+
 	static void _bind_methods();
 
-public:
-	void set_controller_id(int p_controller_id);
-	int get_controller_id() const;
-	String get_controller_name() const;
+	virtual void _bind_tracker();
+	virtual void _unbind_tracker();
+	void _changed_tracker(const StringName p_tracker_name, int p_tracker_type);
+	void _removed_tracker(const StringName p_tracker_name, int p_tracker_type);
 
-	int get_joystick_id() const;
-	bool is_button_pressed(int p_button) const;
-	float get_joystick_axis(int p_axis) const;
+	void _pose_changed(const Ref<XRPose> &p_pose);
 
-	real_t get_rumble() const;
-	void set_rumble(real_t p_rumble);
+public:
+	virtual void _validate_property(PropertyInfo &property) const override;
+	void set_tracker(const StringName p_tracker_name);
+	StringName get_tracker() const;
+
+	void set_pose_name(const StringName p_pose);
+	StringName get_pose_name() const;
 
 	bool get_is_active() const;
-	XRPositionalTracker::TrackerHand get_tracker_hand() const;
+	bool get_has_tracking_data() const;
 
-	Ref<Mesh> get_mesh() const;
+	void trigger_haptic_pulse(const String &p_action_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec = 0);
+
+	Ref<XRPose> get_pose();
 
 	TypedArray<String> get_configuration_warnings() const override;
 
+	XRNode3D();
+	~XRNode3D();
+};
+
+/*
+	XRController3D is a helper node that automatically updates its position based on tracker data.
+
+	It must be a child node of our XROrigin node
+*/
+
+class XRController3D : public XRNode3D {
+	GDCLASS(XRController3D, XRNode3D);
+
+private:
+protected:
+	static void _bind_methods();
+
+	virtual void _bind_tracker() override;
+	virtual void _unbind_tracker() override;
+
+	void _button_pressed(const String &p_name);
+	void _button_released(const String &p_name);
+	void _input_value_changed(const String &p_name, float p_value);
+	void _input_axis_changed(const String &p_name, Vector2 p_value);
+
+public:
+	bool is_button_pressed(const StringName &p_name) const;
+	float get_value(const StringName &p_name) const;
+	Vector2 get_axis(const StringName &p_name) const;
+
+	real_t get_rumble() const;
+	void set_rumble(real_t p_rumble);
+
+	XRPositionalTracker::TrackerHand get_tracker_hand() const;
+
 	XRController3D() {}
 	~XRController3D() {}
 };
@@ -106,33 +156,19 @@ public:
 	It must be a child node of our XROrigin3D node
 */
 
-class XRAnchor3D : public Node3D {
-	GDCLASS(XRAnchor3D, Node3D);
+class XRAnchor3D : public XRNode3D {
+	GDCLASS(XRAnchor3D, XRNode3D);
 
 private:
-	int anchor_id = 1;
-	bool is_active = true;
 	Vector3 size;
-	Ref<Mesh> mesh;
 
 protected:
-	void _notification(int p_what);
 	static void _bind_methods();
 
 public:
-	void set_anchor_id(int p_anchor_id);
-	int get_anchor_id() const;
-	String get_anchor_name() const;
-
-	bool get_is_active() const;
 	Vector3 get_size() const;
-
 	Plane get_plane() const;
 
-	Ref<Mesh> get_mesh() const;
-
-	TypedArray<String> get_configuration_warnings() const override;
-
 	XRAnchor3D() {}
 	~XRAnchor3D() {}
 };
@@ -159,7 +195,7 @@ public:
 	TypedArray<String> get_configuration_warnings() const override;
 
 	void set_tracked_camera(XRCamera3D *p_tracked_camera);
-	void clear_tracked_camera_if(XRCamera3D *p_tracked_camera);
+	XRCamera3D *get_tracked_camera() const;
 
 	real_t get_world_scale() const;
 	void set_world_scale(real_t p_world_scale);