Rework XR positional trackers

29 files changed, 1301 insertions, 744 deletions

diff --git a/doc/classes/XRAnchor3D.xml b/doc/classes/XRAnchor3D.xml
index 94fc8fc13d..2c54c728ed 100644
--- a/doc/classes/XRAnchor3D.xml
+++ b/doc/classes/XRAnchor3D.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="XRAnchor3D" inherits="Node3D" version="4.0">
+<class name="XRAnchor3D" inherits="XRNode3D" version="4.0">
 	<brief_description>
 		An anchor point in AR space.
 	</brief_description>
@@ -11,24 +11,6 @@
 	<tutorials>
 	</tutorials>
 	<methods>
-		<method name="get_anchor_name" qualifiers="const">
-			<return type="String" />
-			<description>
-				Returns the name given to this anchor.
-			</description>
-		</method>
-		<method name="get_is_active" qualifiers="const">
-			<return type="bool" />
-			<description>
-				Returns [code]true[/code] if the anchor is being tracked and [code]false[/code] if no anchor with this ID is currently known.
-			</description>
-		</method>
-		<method name="get_mesh" qualifiers="const">
-			<return type="Mesh" />
-			<description>
-				If provided by the [XRInterface], this returns a mesh object for the anchor. For an anchor, this can be a shape related to the object being tracked or it can be a mesh that provides topology related to the anchor and can be used to create shadows/reflections on surfaces or for generating collision shapes.
-			</description>
-		</method>
 		<method name="get_plane" qualifiers="const">
 			<return type="Plane" />
 			<description>
@@ -42,17 +24,4 @@
 			</description>
 		</method>
 	</methods>
-	<members>
-		<member name="anchor_id" type="int" setter="set_anchor_id" getter="get_anchor_id" default="1">
-			The anchor's ID. You can set this before the anchor itself exists. The first anchor gets an ID of [code]1[/code], the second an ID of [code]2[/code], etc. When anchors get removed, the engine can then assign the corresponding ID to new anchors. The most common situation where anchors "disappear" is when the AR server identifies that two anchors represent different parts of the same plane and merges them.
-		</member>
-	</members>
-	<signals>
-		<signal name="mesh_updated">
-			<argument index="0" name="mesh" type="Mesh" />
-			<description>
-				Emitted when the mesh associated with the anchor changes or when one becomes available. This is especially important for topology that is constantly being [code]mesh_updated[/code].
-			</description>
-		</signal>
-	</signals>
 </class>
diff --git a/doc/classes/XRController3D.xml b/doc/classes/XRController3D.xml
index 35edf5c2b2..eb91196e00 100644
--- a/doc/classes/XRController3D.xml
+++ b/doc/classes/XRController3D.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="XRController3D" inherits="Node3D" version="4.0">
+<class name="XRController3D" inherits="XRNode3D" version="4.0">
 	<brief_description>
 		A spatial node representing a spatially-tracked controller.
 	</brief_description>
@@ -7,63 +7,41 @@
 		This is a helper spatial node that is linked to the tracking of controllers. It also offers several handy passthroughs to the state of buttons and such on the controllers.
 		Controllers are linked by their ID. You can create controller nodes before the controllers are available. If your game always uses two controllers (one for each hand), you can predefine the controllers with ID 1 and 2; they will become active as soon as the controllers are identified. If you expect additional controllers to be used, you should react to the signals and add XRController3D nodes to your scene.
 		The position of the controller node is automatically updated by the [XRServer]. This makes this node ideal to add child nodes to visualize the controller.
+		As many XR runtimes now use a configurable action map all inputs are named.
 	</description>
 	<tutorials>
 		<link title="VR documentation index">https://docs.godotengine.org/en/latest/tutorials/vr/index.html</link>
 	</tutorials>
 	<methods>
-		<method name="get_controller_name" qualifiers="const">
-			<return type="String" />
+		<method name="get_axis" qualifiers="const">
+			<return type="Vector2" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				If active, returns the name of the associated controller if provided by the AR/VR SDK used.
+				Returns a [Vector2] for the input with the given [code]name[/code]. This is used for thumbsticks and thumbpads found on many controllers.
 			</description>
 		</method>
-		<method name="get_is_active" qualifiers="const">
-			<return type="bool" />
+		<method name="get_tracker_hand" qualifiers="const">
+			<return type="int" enum="XRPositionalTracker.TrackerHand" />
 			<description>
-				Returns [code]true[/code] if the bound controller is active. XR systems attempt to track active controllers.
+				Returns the hand holding this controller, if known. See [enum XRPositionalTracker.TrackerHand].
 			</description>
 		</method>
-		<method name="get_joystick_axis" qualifiers="const">
+		<method name="get_value" qualifiers="const">
 			<return type="float" />
-			<argument index="0" name="axis" type="int" />
-			<description>
-				Returns the value of the given axis for things like triggers, touchpads, etc. that are embedded into the controller.
-			</description>
-		</method>
-		<method name="get_joystick_id" qualifiers="const">
-			<return type="int" />
-			<description>
-				Returns the ID of the joystick object bound to this. Every controller tracked by the [XRServer] that has buttons and axis will also be registered as a joystick within Godot. This means that all the normal joystick tracking and input mapping will work for buttons and axis found on the AR/VR controllers. This ID is purely offered as information so you can link up the controller with its joystick entry.
-			</description>
-		</method>
-		<method name="get_mesh" qualifiers="const">
-			<return type="Mesh" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				If provided by the [XRInterface], this returns a mesh associated with the controller. This can be used to visualize the controller.
-			</description>
-		</method>
-		<method name="get_tracker_hand" qualifiers="const">
-			<return type="int" enum="XRPositionalTracker.TrackerHand" />
-			<description>
-				Returns the hand holding this controller, if known. See [enum XRPositionalTracker.TrackerHand].
+				Returns a numeric value for the input with the given [code]name[/code]. This is used for triggers and grip sensors.
 			</description>
 		</method>
 		<method name="is_button_pressed" qualifiers="const">
 			<return type="bool" />
-			<argument index="0" name="button" type="int" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				Returns [code]true[/code] if the button at index [code]button[/code] is pressed. See [enum JoyButton].
+				Returns [code]true[/code] if the button with the given [code]name[/code] is pressed.
 			</description>
 		</method>
 	</methods>
 	<members>
-		<member name="controller_id" type="int" setter="set_controller_id" getter="get_controller_id" default="1">
-			The controller's ID.
-			A controller ID of 0 is unbound and will always result in an inactive node. Controller ID 1 is reserved for the first controller that identifies itself as the left-hand controller and ID 2 is reserved for the first controller that identifies itself as the right-hand controller.
-			For any other controller that the [XRServer] detects, we continue with controller ID 3.
-			When a controller is turned off, its slot is freed. This ensures controllers will keep the same ID even when controllers with lower IDs are turned off.
-		</member>
 		<member name="rumble" type="float" setter="set_rumble" getter="get_rumble" default="0.0">
 			The degree to which the controller vibrates. Ranges from [code]0.0[/code] to [code]1.0[/code] with precision [code].01[/code]. If changed, updates [member XRPositionalTracker.rumble] accordingly.
 			This is a useful property to animate if you want the controller to vibrate for a limited duration.
@@ -71,21 +49,29 @@
 	</members>
 	<signals>
 		<signal name="button_pressed">
-			<argument index="0" name="button" type="int" />
+			<argument index="0" name="name" type="String" />
 			<description>
 				Emitted when a button on this controller is pressed.
 			</description>
 		</signal>
 		<signal name="button_released">
-			<argument index="0" name="button" type="int" />
+			<argument index="0" name="name" type="String" />
 			<description>
 				Emitted when a button on this controller is released.
 			</description>
 		</signal>
-		<signal name="mesh_updated">
-			<argument index="0" name="mesh" type="Mesh" />
+		<signal name="input_axis_changed">
+			<argument index="0" name="name" type="String" />
+			<argument index="1" name="value" type="Vector2" />
+			<description>
+				Emitted when a thumbstick or thumbpad on this controller is moved.
+			</description>
+		</signal>
+		<signal name="input_value_changed">
+			<argument index="0" name="name" type="String" />
+			<argument index="1" name="value" type="float" />
 			<description>
-				Emitted when the mesh associated with the controller changes or when one becomes available. Generally speaking this will be a static mesh after becoming available.
+				Emitted when a trigger or similar input on this controller changes value.
 			</description>
 		</signal>
 	</signals>
diff --git a/doc/classes/XRInterface.xml b/doc/classes/XRInterface.xml
index ffc2bc138d..27713498ee 100644
--- a/doc/classes/XRInterface.xml
+++ b/doc/classes/XRInterface.xml
@@ -63,6 +63,20 @@
 				Is [code]true[/code] if this interface has been initialised.
 			</description>
 		</method>
+		<method name="trigger_haptic_pulse">
+			<return type="void" />
+			<argument index="0" name="action_name" type="String" />
+			<argument index="1" name="tracker_name" type="StringName" />
+			<argument index="2" name="frequency" type="float" />
+			<argument index="3" name="amplitude" type="float" />
+			<argument index="4" name="duration_sec" type="float" />
+			<argument index="5" name="delay_sec" type="float" />
+			<description>
+				Triggers a haptic pulse on a device associated with this interface.
+				[code]action_name[/code] is the name of the action for this pulse.
+				[code]tracker_name[/code] is optional and can be used to direct the pulse to a specific device provided that device is bound to this haptic.
+			</description>
+		</method>
 		<method name="uninitialize">
 			<return type="void" />
 			<description>
@@ -88,20 +102,17 @@
 		<constant name="XR_STEREO" value="2" enum="Capabilities">
 			This interface supports stereoscopic rendering.
 		</constant>
-		<constant name="XR_AR" value="4" enum="Capabilities">
-			This interface supports AR (video background and real world tracking).
+		<constant name="XR_QUAD" value="4" enum="Capabilities">
+			This interface supports quad rendering (not yet supported by Godot).
 		</constant>
-		<constant name="XR_EXTERNAL" value="8" enum="Capabilities">
-			This interface outputs to an external device. If the main viewport is used, the on screen output is an unmodified buffer of either the left or right eye (stretched if the viewport size is not changed to the same aspect ratio of [method get_render_target_size]). Using a separate viewport node frees up the main viewport for other purposes.
-		</constant>
-		<constant name="EYE_MONO" value="0" enum="Eyes">
-			Mono output, this is mostly used internally when retrieving positioning information for our camera node or when stereo scopic rendering is not supported.
+		<constant name="XR_VR" value="8" enum="Capabilities">
+			this interface supports VR.
 		</constant>
-		<constant name="EYE_LEFT" value="1" enum="Eyes">
-			Left eye output, this is mostly used internally when rendering the image for the left eye and obtaining positioning and projection information.
+		<constant name="XR_AR" value="16" enum="Capabilities">
+			This interface supports AR (video background and real world tracking).
 		</constant>
-		<constant name="EYE_RIGHT" value="2" enum="Eyes">
-			Right eye output, this is mostly used internally when rendering the image for the right eye and obtaining positioning and projection information.
+		<constant name="XR_EXTERNAL" value="32" enum="Capabilities">
+			This interface outputs to an external device. If the main viewport is used, the on screen output is an unmodified buffer of either the left or right eye (stretched if the viewport size is not changed to the same aspect ratio of [method get_render_target_size]). Using a separate viewport node frees up the main viewport for other purposes.
 		</constant>
 		<constant name="XR_NORMAL_TRACKING" value="0" enum="TrackingStatus">
 			Tracking is behaving as expected.
diff --git a/doc/classes/XRInterfaceExtension.xml b/doc/classes/XRInterfaceExtension.xml
index 84b46e0ddd..4328488ced 100644
--- a/doc/classes/XRInterfaceExtension.xml
+++ b/doc/classes/XRInterfaceExtension.xml
@@ -55,6 +55,17 @@
 			<description>
 			</description>
 		</method>
+		<method name="_get_suggested_pose_names" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<argument index="0" name="tracker_name" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_suggested_tracker_names" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
 		<method name="_get_tracking_status" qualifiers="virtual const">
 			<return type="int" />
 			<description>
@@ -99,6 +110,17 @@
 			<description>
 			</description>
 		</method>
+		<method name="_trigger_haptic_pulse" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="action_name" type="String" />
+			<argument index="1" name="tracker_name" type="StringName" />
+			<argument index="2" name="frequency" type="float" />
+			<argument index="3" name="amplitude" type="float" />
+			<argument index="4" name="duration_sec" type="float" />
+			<argument index="5" name="delay_sec" type="float" />
+			<description>
+			</description>
+		</method>
 		<method name="_uninitialize" qualifiers="virtual">
 			<return type="void" />
 			<description>
diff --git a/doc/classes/XRNode3D.xml b/doc/classes/XRNode3D.xml
new file mode 100644
index 0000000000..2e6d11d729
--- /dev/null
+++ b/doc/classes/XRNode3D.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="XRNode3D" inherits="Node3D" version="4.0">
+	<brief_description>
+		A spatial node that has its position automatically updated by the [XRServer].
+	</brief_description>
+	<description>
+		This node can be bound to a specific pose of a [XRPositionalTracker] and will automatically have its [member Node3D.transform] updated by the [XRServer]. Nodes of this type must be added as children of the [XROrigin3D] node.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="get_has_tracking_data" qualifiers="const">
+			<return type="bool" />
+			<description>
+				Returns [code]true[/code] if the [member tracker] has current tracking data for the [member pose] being tracked.
+			</description>
+		</method>
+		<method name="get_is_active" qualifiers="const">
+			<return type="bool" />
+			<description>
+				Returns [code]true[/code] if the [member tracker] has been registered and the [member pose] is being tracked.
+			</description>
+		</method>
+		<method name="get_pose">
+			<return type="XRPose" />
+			<description>
+				Returns the [XRPose] containing the current state of the pose being tracked. This gives access to additional properties of this pose.
+			</description>
+		</method>
+		<method name="trigger_haptic_pulse">
+			<return type="void" />
+			<argument index="0" name="action_name" type="String" />
+			<argument index="1" name="frequency" type="float" />
+			<argument index="2" name="amplitude" type="float" />
+			<argument index="3" name="duration_sec" type="float" />
+			<argument index="4" name="delay_sec" type="float" />
+			<description>
+				Triggers a haptic pulse on a device associated with this interface.
+				[code]action_name[/code] is the name of the action for this pulse.
+			</description>
+		</method>
+	</methods>
+	<members>
+		<member name="pose" type="StringName" setter="set_pose_name" getter="get_pose_name" default="&amp;&quot;default&quot;">
+			The name of the pose we're bound to. Which poses a tracker supports is not known during design time.
+			Godot defines number of standard pose names such as [code]aim[/code] and [code]grip[/code] but other may be configured within a given [XRInterface].
+		</member>
+		<member name="tracker" type="StringName" setter="set_tracker" getter="get_tracker" default="&amp;&quot;&quot;">
+			The name of the tracker we're bound to. Which trackers are available is not known during design time.
+			Godot defines a number of standard trackers such as [code]left_hand[/code] and [code]right_hand[/code] but others may be configured within a given [XRInterface].
+		</member>
+	</members>
+</class>
diff --git a/doc/classes/XRPose.xml b/doc/classes/XRPose.xml
new file mode 100644
index 0000000000..0de2bc9e48
--- /dev/null
+++ b/doc/classes/XRPose.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="XRPose" inherits="RefCounted" version="4.0">
+	<brief_description>
+		This object contains all data related to a pose on a tracked object.
+	</brief_description>
+	<description>
+		XR runtimes often identify multiple locations on devices such as controllers that are spatially tracked.
+		Orientation, location, linear velocity and angular velocity are all provided for each pose by the XR runtime. This object contains this state of a pose.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="get_adjusted_transform" qualifiers="const">
+			<return type="Transform3D" />
+			<description>
+				Returns the [member transform] with world scale and our reference frame applied. This is the transform used to position [XRNode3D] objects.
+			</description>
+		</method>
+	</methods>
+	<members>
+		<member name="angular_velocity" type="Vector3" setter="set_angular_velocity" getter="get_angular_velocity" default="Vector3(0, 0, 0)">
+			The angular velocity for this pose.
+		</member>
+		<member name="has_tracking_data" type="bool" setter="set_has_tracking_data" getter="get_has_tracking_data" default="false">
+			If [code]true[/code] our tracking data is up to date. If [code]false[/code] we're no longer receiving new tracking data and our state is whatever that last valid state was.
+		</member>
+		<member name="linear_velocity" type="Vector3" setter="set_linear_velocity" getter="get_linear_velocity" default="Vector3(0, 0, 0)">
+			The linear velocity of this pose.
+		</member>
+		<member name="name" type="StringName" setter="set_name" getter="get_name" default="&amp;&quot;&quot;">
+			The name of this pose. Pose names are often driven by an action map setup by the user. Godot does suggest a number of pose names that it expects [XRInterface]s to implement:
+			- [code]root[/code] defines a root location, often used for tracked objects that do not have further nodes.
+			- [code]aim[/code] defines the tip of a controller with the orientation pointing outwards, for instance: add your raycasts to this.
+			- [code]grip[/code] defines the location where the user grips the controller
+			- [code]skeleton[/code] defines the root location a hand mesh should be placed when using hand tracking and the animated skeleton supplied by the XR runtime.
+		</member>
+		<member name="transform" type="Transform3D" setter="set_transform" getter="get_transform" default="Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)">
+			The transform containing the original and transform as reported by the XR runtime.
+		</member>
+	</members>
+</class>
diff --git a/doc/classes/XRPositionalTracker.xml b/doc/classes/XRPositionalTracker.xml
index d231bfde74..bd6a518835 100644
--- a/doc/classes/XRPositionalTracker.xml
+++ b/doc/classes/XRPositionalTracker.xml
@@ -5,86 +5,113 @@
 	</brief_description>
 	<description>
 		An instance of this object represents a device that is tracked, such as a controller or anchor point. HMDs aren't represented here as they are handled internally.
-		As controllers are turned on and the AR/VR interface detects them, instances of this object are automatically added to this list of active tracking objects accessible through the [XRServer].
-		The [XRController3D] and [XRAnchor3D] both consume objects of this type and should be used in your project. The positional trackers are just under-the-hood objects that make this all work. These are mostly exposed so that GDNative-based interfaces can interact with them.
+		As controllers are turned on and the [XRInterface] detects them, instances of this object are automatically added to this list of active tracking objects accessible through the [XRServer].
+		The [XRController3D] and [XRAnchor3D] both consume objects of this type and should be used in your project. The positional trackers are just under-the-hood objects that make this all work. These are mostly exposed so that GDExtension-based interfaces can interact with them.
 	</description>
 	<tutorials>
 		<link title="VR documentation index">https://docs.godotengine.org/en/latest/tutorials/vr/index.html</link>
 	</tutorials>
 	<methods>
-		<method name="get_joy_id" qualifiers="const">
-			<return type="int" />
+		<method name="get_input" qualifiers="const">
+			<return type="Variant" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				If this is a controller that is being tracked, the controller will also be represented by a joystick entry with this ID.
+				Returns an input for this tracker. It can return a boolean, float or [Vector2] value depending on whether the input is a button, trigger or thumbstick/thumbpad.
 			</description>
 		</method>
-		<method name="get_mesh" qualifiers="const">
-			<return type="Mesh" />
+		<method name="get_pose" qualifiers="const">
+			<return type="XRPose" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				Returns the mesh related to a controller or anchor point if one is available.
+				Returns the current [XRPose] state object for the bound [code]pose[/code].
 			</description>
 		</method>
-		<method name="get_orientation" qualifiers="const">
-			<return type="Basis" />
+		<method name="has_pose" qualifiers="const">
+			<return type="bool" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				Returns the controller's orientation matrix.
+				Returns [code]true[/code] if the bound [code]tracker[/code] is available and is currently tracking the bound [code]pose[/code].
 			</description>
 		</method>
-		<method name="get_position" qualifiers="const">
-			<return type="Vector3" />
+		<method name="invalidate_pose">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
 			<description>
-				Returns the world-space controller position.
+				Marks this pose as invalid, we don't clear the last reported state but it allows users to decide if trackers need to be hidden if we loose tracking or just remain at their last known position.
 			</description>
 		</method>
-		<method name="get_tracker_hand" qualifiers="const">
-			<return type="int" enum="XRPositionalTracker.TrackerHand" />
+		<method name="set_input">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
+			<argument index="1" name="value" type="Variant" />
 			<description>
-				Returns the hand holding this tracker, if known. See [enum TrackerHand] constants.
+				Changes the value for the given input. This method is called by a [XRInterface] implementation and should not be used directly.
 			</description>
 		</method>
-		<method name="get_tracker_id" qualifiers="const">
-			<return type="int" />
+		<method name="set_pose">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
+			<argument index="1" name="transform" type="Transform3D" />
+			<argument index="2" name="linear_velocity" type="Vector3" />
+			<argument index="3" name="angular_velocity" type="Vector3" />
 			<description>
-				Returns the internal tracker ID. This uniquely identifies the tracker per tracker type and matches the ID you need to specify for nodes such as the [XRController3D] and [XRAnchor3D] nodes.
+				Sets the transform, linear velocity and angular velocity for the given pose. This method is called by a [XRInterface] implementation and should not be used directly.
 			</description>
 		</method>
-		<method name="get_tracker_name" qualifiers="const">
-			<return type="StringName" />
+	</methods>
+	<members>
+		<member name="description" type="String" setter="set_tracker_desc" getter="get_tracker_desc" default="&quot;&quot;">
+			The description of this tracker.
+		</member>
+		<member name="hand" type="int" setter="set_tracker_hand" getter="get_tracker_hand" enum="XRPositionalTracker.TrackerHand" default="0">
+			Defines which hand this tracker relates to.
+		</member>
+		<member name="name" type="StringName" setter="set_tracker_name" getter="get_tracker_name" default="&amp;&quot;Unknown&quot;">
+			The unique name of this tracker. The trackers that are available differ between various XR runtimes and can often be configured by the user. Godot maintains a number of reserved names that it expects the [XRInterface] to implement if applicable:
+			- [code]left_hand[/code] identifies the controller held in the players left hand
+			- [code]right_hand[/code] identifies the controller held in the players right hand
+		</member>
+		<member name="rumble" type="float" setter="set_rumble" getter="get_rumble" default="0.0">
+			The degree to which the tracker rumbles. Ranges from [code]0.0[/code] to [code]1.0[/code] with precision [code].01[/code].
+		</member>
+		<member name="type" type="int" setter="set_tracker_type" getter="get_tracker_type" enum="XRServer.TrackerType" default="128">
+			The type of tracker.
+		</member>
+	</members>
+	<signals>
+		<signal name="button_pressed">
+			<argument index="0" name="name" type="String" />
 			<description>
-				Returns the controller or anchor point's name, if applicable.
+				Emitted when a button on this tracker is pressed. Note that many XR runtimes allow other inputs to be mapped to buttons.
 			</description>
-		</method>
-		<method name="get_tracker_type" qualifiers="const">
-			<return type="int" enum="XRServer.TrackerType" />
+		</signal>
+		<signal name="button_released">
+			<argument index="0" name="name" type="String" />
 			<description>
-				Returns the tracker's type, which will be one of the values from the [enum XRServer.TrackerType] enum.
+				Emitted when a button on this tracker is released.
 			</description>
-		</method>
-		<method name="get_transform" qualifiers="const">
-			<return type="Transform3D" />
-			<argument index="0" name="adjust_by_reference_frame" type="bool" />
+		</signal>
+		<signal name="input_axis_changed">
+			<argument index="0" name="name" type="String" />
+			<argument index="1" name="vector" type="Vector2" />
 			<description>
-				Returns the transform combining this device's orientation and position.
+				Emitted when a thumbstick or thumbpad on this tracker moves.
 			</description>
-		</method>
-		<method name="is_tracking_orientation" qualifiers="const">
-			<return type="bool" />
+		</signal>
+		<signal name="input_value_changed">
+			<argument index="0" name="name" type="String" />
+			<argument index="1" name="value" type="float" />
 			<description>
-				Returns [code]true[/code] if this device is tracking orientation.
+				Emitted when a trigger or similar input on this tracker changes value.
 			</description>
-		</method>
-		<method name="is_tracking_position" qualifiers="const">
-			<return type="bool" />
+		</signal>
+		<signal name="pose_changed">
+			<argument index="0" name="pose" type="XRPose" />
 			<description>
-				Returns [code]true[/code] if this device is tracking position.
+				Emitted when the state of a pose tracked by this tracker changes.
 			</description>
-		</method>
-	</methods>
-	<members>
-		<member name="rumble" type="float" setter="set_rumble" getter="get_rumble" default="0.0">
-			The degree to which the tracker rumbles. Ranges from [code]0.0[/code] to [code]1.0[/code] with precision [code].01[/code].
-		</member>
-	</members>
+		</signal>
+	</signals>
 	<constants>
 		<constant name="TRACKER_HAND_UNKNOWN" value="0" enum="TrackerHand">
 			The hand this tracker is held in is unknown or not applicable.
diff --git a/doc/classes/XRServer.xml b/doc/classes/XRServer.xml
index 0929094fd1..87164ebb52 100644
--- a/doc/classes/XRServer.xml
+++ b/doc/classes/XRServer.xml
@@ -90,20 +90,21 @@
 		<method name="get_reference_frame" qualifiers="const">
 			<return type="Transform3D" />
 			<description>
-				Returns the reference frame transform. Mostly used internally and exposed for GDNative build interfaces.
+				Returns the reference frame transform. Mostly used internally and exposed for GDExtension build interfaces.
 			</description>
 		</method>
 		<method name="get_tracker" qualifiers="const">
 			<return type="XRPositionalTracker" />
-			<argument index="0" name="idx" type="int" />
+			<argument index="0" name="tracker_name" type="StringName" />
 			<description>
-				Returns the positional tracker at the given ID.
+				Returns the positional tracker with this name.
 			</description>
 		</method>
-		<method name="get_tracker_count" qualifiers="const">
-			<return type="int" />
+		<method name="get_trackers">
+			<return type="Dictionary" />
+			<argument index="0" name="tracker_types" type="int" />
 			<description>
-				Returns the number of trackers currently registered.
+				Returns a dictionary of trackers for this type.
 			</description>
 		</method>
 		<method name="remove_interface">
@@ -145,7 +146,6 @@
 		<signal name="tracker_added">
 			<argument index="0" name="tracker_name" type="StringName" />
 			<argument index="1" name="type" type="int" />
-			<argument index="2" name="id" type="int" />
 			<description>
 				Emitted when a new tracker has been added. If you don't use a fixed number of controllers or if you're using [XRAnchor3D]s for an AR solution, it is important to react to this signal to add the appropriate [XRController3D] or [XRAnchor3D] nodes related to this new tracker.
 			</description>
@@ -153,20 +153,29 @@
 		<signal name="tracker_removed">
 			<argument index="0" name="tracker_name" type="StringName" />
 			<argument index="1" name="type" type="int" />
-			<argument index="2" name="id" type="int" />
 			<description>
 				Emitted when a tracker is removed. You should remove any [XRController3D] or [XRAnchor3D] points if applicable. This is not mandatory, the nodes simply become inactive and will be made active again when a new tracker becomes available (i.e. a new controller is switched on that takes the place of the previous one).
 			</description>
 		</signal>
+		<signal name="tracker_updated">
+			<argument index="0" name="tracker_name" type="StringName" />
+			<argument index="1" name="type" type="int" />
+			<description>
+				Emitted when an existing tracker has been updated. This can happen if the user switches controllers.
+			</description>
+		</signal>
 	</signals>
 	<constants>
-		<constant name="TRACKER_CONTROLLER" value="1" enum="TrackerType">
+		<constant name="TRACKER_HEAD" value="1" enum="TrackerType">
+			The tracker tracks the location of the players head. This is usually a location centered between the players eyes. Note that for handheld AR devices this can be the current location of the device.
+		</constant>
+		<constant name="TRACKER_CONTROLLER" value="2" enum="TrackerType">
 			The tracker tracks the location of a controller.
 		</constant>
-		<constant name="TRACKER_BASESTATION" value="2" enum="TrackerType">
+		<constant name="TRACKER_BASESTATION" value="4" enum="TrackerType">
 			The tracker tracks the location of a base station.
 		</constant>
-		<constant name="TRACKER_ANCHOR" value="4" enum="TrackerType">
+		<constant name="TRACKER_ANCHOR" value="8" enum="TrackerType">
 			The tracker tracks the location and size of an AR anchor.
 		</constant>
 		<constant name="TRACKER_ANY_KNOWN" value="127" enum="TrackerType">
diff --git a/main/main.cpp b/main/main.cpp
index 3cc7923cc2..a07533180a 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -2522,6 +2522,9 @@ bool Main::iteration() {
 
 	bool exit = false;
 
+	// process all our active interfaces
+	XRServer::get_singleton()->_process();
+
 	for (int iters = 0; iters < advance.physics_steps; ++iters) {
 		if (Input::get_singleton()->is_using_input_buffering() && agile_input_event_flushing) {
 			Input::get_singleton()->flush_buffered_events();
diff --git a/modules/mobile_vr/mobile_vr_interface.cpp b/modules/mobile_vr/mobile_vr_interface.cpp
index fc1a118e4f..7dd26c6905 100644
--- a/modules/mobile_vr/mobile_vr_interface.cpp
+++ b/modules/mobile_vr/mobile_vr_interface.cpp
@@ -126,6 +126,8 @@ void MobileVRInterface::set_position_from_sensors() {
 	// 9dof is a misleading marketing term coming from 3 accelerometer axis + 3 gyro axis + 3 magnetometer axis = 9 axis
 	// but in reality this only offers 3 dof (yaw, pitch, roll) orientation
 
+	Basis orientation;
+
 	uint64_t ticks = OS::get_singleton()->get_ticks_usec();
 	uint64_t ticks_elapsed = ticks - last_ticks;
 	float delta_time = (double)ticks_elapsed / 1000000.0;
@@ -207,8 +209,8 @@ void MobileVRInterface::set_position_from_sensors() {
 		};
 	};
 
-	// JIC
-	orientation.orthonormalize();
+	// and copy to our head transform
+	head_transform.basis = orientation.orthonormalized();
 
 	last_ticks = ticks;
 };
@@ -318,7 +320,7 @@ bool MobileVRInterface::initialize() {
 	ERR_FAIL_NULL_V(xr_server, false);
 
 	if (!initialized) {
-		// reset our sensor data and orientation
+		// reset our sensor data
 		mag_count = 0;
 		has_gyro = false;
 		sensor_first = true;
@@ -326,9 +328,15 @@ bool MobileVRInterface::initialize() {
 		mag_next_max = Vector3(-10000, -10000, -10000);
 		mag_current_min = Vector3(0, 0, 0);
 		mag_current_max = Vector3(0, 0, 0);
+		head_transform.basis = Basis();
+		head_transform.origin = Vector3(0.0, eye_height, 0.0);
 
-		// reset our orientation
-		orientation = Basis();
+		// we must create a tracker for our head
+		head.instantiate();
+		head->set_tracker_type(XRServer::TRACKER_HEAD);
+		head->set_tracker_name("head");
+		head->set_tracker_desc("Players head");
+		xr_server->add_tracker(head);
 
 		// make this our primary interface
 		xr_server->set_primary_interface(this);
@@ -343,10 +351,19 @@ bool MobileVRInterface::initialize() {
 
 void MobileVRInterface::uninitialize() {
 	if (initialized) {
+		// do any cleanup here...
 		XRServer *xr_server = XRServer::get_singleton();
-		if (xr_server != nullptr && xr_server->get_primary_interface() == this) {
-			// no longer our primary interface
-			xr_server->set_primary_interface(nullptr);
+		if (xr_server != nullptr) {
+			if (head.is_valid()) {
+				xr_server->remove_tracker(head);
+
+				head.unref();
+			}
+
+			if (xr_server->get_primary_interface() == this) {
+				// no longer our primary interface
+				xr_server->set_primary_interface(nullptr);
+			}
 		}
 
 		initialized = false;
@@ -377,11 +394,10 @@ Transform3D MobileVRInterface::get_camera_transform() {
 		float world_scale = xr_server->get_world_scale();
 
 		// just scale our origin point of our transform
-		Transform3D hmd_transform;
-		hmd_transform.basis = orientation;
-		hmd_transform.origin = Vector3(0.0, eye_height * world_scale, 0.0);
+		Transform3D _head_transform = head_transform;
+		_head_transform.origin *= world_scale;
 
-		transform_for_eye = (xr_server->get_reference_frame()) * hmd_transform;
+		transform_for_eye = (xr_server->get_reference_frame()) * _head_transform;
 	}
 
 	return transform_for_eye;
@@ -409,11 +425,10 @@ Transform3D MobileVRInterface::get_transform_for_view(uint32_t p_view, const Tra
 		};
 
 		// just scale our origin point of our transform
-		Transform3D hmd_transform;
-		hmd_transform.basis = orientation;
-		hmd_transform.origin = Vector3(0.0, eye_height * world_scale, 0.0);
+		Transform3D _head_transform = head_transform;
+		_head_transform.origin *= world_scale;
 
-		transform_for_eye = p_cam_transform * (xr_server->get_reference_frame()) * hmd_transform * transform_for_eye;
+		transform_for_eye = p_cam_transform * (xr_server->get_reference_frame()) * _head_transform * transform_for_eye;
 	} else {
 		// huh? well just return what we got....
 		transform_for_eye = p_cam_transform;
@@ -476,7 +491,16 @@ void MobileVRInterface::process() {
 	_THREAD_SAFE_METHOD_
 
 	if (initialized) {
+		// update our head transform orientation
 		set_position_from_sensors();
+
+		// update our head transform position (should be constant)
+		head_transform.origin = Vector3(0.0, eye_height, 0.0);
+
+		if (head.is_valid()) {
+			// Set our head position, note in real space, reference frame and world scale is applied later
+			head->set_pose("default", head_transform, Vector3(), Vector3());
+		}
 	};
 };
 
diff --git a/modules/mobile_vr/mobile_vr_interface.h b/modules/mobile_vr/mobile_vr_interface.h
index a843e1188b..34bd1da43b 100644
--- a/modules/mobile_vr/mobile_vr_interface.h
+++ b/modules/mobile_vr/mobile_vr_interface.h
@@ -53,7 +53,6 @@ class MobileVRInterface : public XRInterface {
 private:
 	bool initialized = false;
 	XRInterface::TrackingStatus tracking_state;
-	Basis orientation;
 
 	// Just set some defaults for these. At some point we need to look at adding a lookup table for common device + headset combos and/or support reading cardboard QR codes
 	double eye_height = 1.85;
@@ -68,6 +67,10 @@ private:
 	double k2 = 0.215;
 	double aspect = 1.0;
 
+	// at a minimum we need a tracker for our head
+	Ref<XRPositionalTracker> head;
+	Transform3D head_transform;
+
 	/*
 		logic for processing our sensor data, this was originally in our positional tracker logic but I think
 		that doesn't make sense in hindsight. It only makes marginally more sense to park it here for now,
diff --git a/modules/webxr/doc_classes/WebXRInterface.xml b/modules/webxr/doc_classes/WebXRInterface.xml
index 16d671c9e9..6e224a8242 100644
--- a/modules/webxr/doc_classes/WebXRInterface.xml
+++ b/modules/webxr/doc_classes/WebXRInterface.xml
@@ -87,7 +87,7 @@
 		There are several ways to handle "controller" input:
 		- Using [XRController3D] nodes and their [signal XRController3D.button_pressed] and [signal XRController3D.button_released] signals. This is how controllers are typically handled in AR/VR apps in Godot, however, this will only work with advanced VR controllers like the Oculus Touch or Index controllers, for example. The buttons codes are defined by [url=https://immersive-web.github.io/webxr-gamepads-module/#xr-standard-gamepad-mapping]Section 3.3 of the WebXR Gamepads Module[/url].
 		- Using [method Node._unhandled_input] and [InputEventJoypadButton] or [InputEventJoypadMotion]. This works the same as normal joypads, except the [member InputEvent.device] starts at 100, so the left controller is 100 and the right controller is 101, and the button codes are also defined by [url=https://immersive-web.github.io/webxr-gamepads-module/#xr-standard-gamepad-mapping]Section 3.3 of the WebXR Gamepads Module[/url].
-		- Using the [signal select], [signal squeeze] and related signals. This method will work for both advanced VR controllers, and non-traditional "controllers" like a tap on the screen, a spoken voice command or a button press on the device itself. The [code]controller_id[/code] passed to these signals is the same id as used in [member XRController3D.controller_id].
+		- Using the [signal select], [signal squeeze] and related signals. This method will work for both advanced VR controllers, and non-traditional "controllers" like a tap on the screen, a spoken voice command or a button press on the device itself.
 		You can use one or all of these methods to allow your game or app to support a wider or narrower set of devices and input methods, or to allow more advanced interactions with more advanced devices.
 	</description>
 	<tutorials>
diff --git a/modules/webxr/webxr_interface_js.cpp b/modules/webxr/webxr_interface_js.cpp
index 10c17aa672..2676b3cf80 100644
--- a/modules/webxr/webxr_interface_js.cpp
+++ b/modules/webxr/webxr_interface_js.cpp
@@ -163,9 +163,14 @@ String WebXRInterfaceJS::get_reference_space_type() const {
 
 Ref<XRPositionalTracker> WebXRInterfaceJS::get_controller(int p_controller_id) const {
 	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, nullptr);
+	ERR_FAIL_NULL_V(xr_server, Ref<XRPositionalTracker>());
 
-	return xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, p_controller_id);
+	// TODO support more then two controllers
+	if (p_controller_id >= 0 && p_controller_id < 2) {
+		return controllers[p_controller_id];
+	};
+
+	return Ref<XRPositionalTracker>();
 }
 
 String WebXRInterfaceJS::get_visibility_state() const {
@@ -224,6 +229,13 @@ bool WebXRInterfaceJS::initialize() {
 			return false;
 		}
 
+		// we must create a tracker for our head
+		head_tracker.instantiate();
+		head_tracker->set_tracker_type(XRServer::TRACKER_HEAD);
+		head_tracker->set_tracker_name("head");
+		head_tracker->set_tracker_desc("Players head");
+		xr_server->add_tracker(head_tracker);
+
 		// make this our primary interface
 		xr_server->set_primary_interface(this);
 
@@ -254,9 +266,17 @@ bool WebXRInterfaceJS::initialize() {
 void WebXRInterfaceJS::uninitialize() {
 	if (initialized) {
 		XRServer *xr_server = XRServer::get_singleton();
-		if (xr_server != nullptr && xr_server->get_primary_interface() == this) {
-			// no longer our primary interface
-			xr_server->set_primary_interface(nullptr);
+		if (xr_server != nullptr) {
+			if (head_tracker.is_valid()) {
+				xr_server->remove_tracker(head_tracker);
+
+				head_tracker.unref();
+			}
+
+			if (xr_server->get_primary_interface() == this) {
+				// no longer our primary interface
+				xr_server->set_primary_interface(nullptr);
+			}
 		}
 
 		godot_webxr_uninitialize();
@@ -373,9 +393,9 @@ Vector<BlitToScreen> WebXRInterfaceJS::commit_views(RID p_render_target, const R
 	}
 
 	// @todo Refactor this to be based on "views" rather than "eyes".
-	godot_webxr_commit_for_eye(XRInterface::EYE_LEFT);
+	godot_webxr_commit_for_eye(1);
 	if (godot_webxr_get_view_count() > 1) {
-		godot_webxr_commit_for_eye(XRInterface::EYE_RIGHT);
+		godot_webxr_commit_for_eye(2);
 	}
 
 	return blit_to_screen;
@@ -385,6 +405,11 @@ void WebXRInterfaceJS::process() {
 	if (initialized) {
 		godot_webxr_sample_controller_data();
 
+		if (head_tracker.is_valid()) {
+			// TODO set default pose to our head location (i.e. get_camera_transform without world scale and reference frame applied)
+			// head_tracker->set_pose("default", head_transform, Vector3(), Vector3());
+		}
+
 		int controller_count = godot_webxr_get_controller_count();
 		if (controller_count == 0) {
 			return;
@@ -400,51 +425,70 @@ void WebXRInterfaceJS::_update_tracker(int p_controller_id) {
 	XRServer *xr_server = XRServer::get_singleton();
 	ERR_FAIL_NULL(xr_server);
 
-	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, p_controller_id + 1);
+	// need to support more then two controllers...
+	if (p_controller_id < 0 || p_controller_id > 1) {
+		return;
+	}
+
+	Ref<XRPositionalTracker> tracker = controllers[p_controller_id];
 	if (godot_webxr_is_controller_connected(p_controller_id)) {
 		if (tracker.is_null()) {
 			tracker.instantiate();
 			tracker->set_tracker_type(XRServer::TRACKER_CONTROLLER);
 			// Controller id's 0 and 1 are always the left and right hands.
 			if (p_controller_id < 2) {
-				tracker->set_tracker_name(p_controller_id == 0 ? "Left" : "Right");
+				tracker->set_tracker_name(p_controller_id == 0 ? "left_hand" : "right_hand");
+				tracker->set_tracker_desc(p_controller_id == 0 ? "Left hand controller" : "Right hand controller");
 				tracker->set_tracker_hand(p_controller_id == 0 ? XRPositionalTracker::TRACKER_HAND_LEFT : XRPositionalTracker::TRACKER_HAND_RIGHT);
+			} else {
+				char name[1024];
+				sprintf(name, "tracker_%i", p_controller_id);
+				tracker->set_tracker_name(name);
+				tracker->set_tracker_desc(name);
 			}
-			// Use the ids we're giving to our "virtual" gamepads.
-			tracker->set_joy_id(p_controller_id + 100);
 			xr_server->add_tracker(tracker);
 		}
 
-		Input *input = Input::get_singleton();
-
 		float *tracker_matrix = godot_webxr_get_controller_transform(p_controller_id);
 		if (tracker_matrix) {
+			// Note, poses should NOT have world scale and our reference frame applied!
 			Transform3D transform = _js_matrix_to_transform(tracker_matrix);
-			tracker->set_position(transform.origin);
-			tracker->set_orientation(transform.basis);
+			tracker->set_pose("default", transform, Vector3(), Vector3());
 			free(tracker_matrix);
 		}
 
+		// TODO implement additional poses such as "aim" and "grip"
+
 		int *buttons = godot_webxr_get_controller_buttons(p_controller_id);
 		if (buttons) {
+			// TODO buttons should be named properly, this is just a temporary fix
 			for (int i = 0; i < buttons[0]; i++) {
-				input->joy_button(p_controller_id + 100, (JoyButton)i, *((float *)buttons + (i + 1)));
+				char name[1024];
+				sprintf(name, "button_%i", i);
+
+				float value = *((float *)buttons + (i + 1));
+				bool state = value > 0.0;
+				tracker->set_input(name, state);
 			}
 			free(buttons);
 		}
 
 		int *axes = godot_webxr_get_controller_axes(p_controller_id);
 		if (axes) {
+			// TODO again just a temporary fix, split these between proper float and vector2 inputs
 			for (int i = 0; i < axes[0]; i++) {
-				Input::JoyAxisValue joy_axis;
-				joy_axis.min = -1;
-				joy_axis.value = *((float *)axes + (i + 1));
-				input->joy_axis(p_controller_id + 100, (JoyAxis)i, joy_axis);
+				char name[1024];
+				sprintf(name, "axis_%i", i);
+
+				float value = *((float *)axes + (i + 1));
+				;
+				tracker->set_input(name, value);
 			}
 			free(axes);
 		}
 	} else if (tracker.is_valid()) {
 		xr_server->remove_tracker(tracker);
+		controllers[p_controller_id].unref();
 	}
 }
 
@@ -454,7 +498,7 @@ void WebXRInterfaceJS::_on_controller_changed() {
 	for (int i = 0; i < 2; i++) {
 		bool controller_connected = godot_webxr_is_controller_connected(i);
 		if (controllers_state[i] != controller_connected) {
-			Input::get_singleton()->joy_connection_changed(i + 100, controller_connected, i == 0 ? "Left" : "Right", "");
+			// Input::get_singleton()->joy_connection_changed(i + 100, controller_connected, i == 0 ? "Left" : "Right", "");
 			controllers_state[i] = controller_connected;
 		}
 	}
diff --git a/modules/webxr/webxr_interface_js.h b/modules/webxr/webxr_interface_js.h
index eb77f35f39..6e6548c946 100644
--- a/modules/webxr/webxr_interface_js.h
+++ b/modules/webxr/webxr_interface_js.h
@@ -46,6 +46,7 @@ class WebXRInterfaceJS : public WebXRInterface {
 
 private:
 	bool initialized;
+	Ref<XRPositionalTracker> head_tracker;
 
 	String session_mode;
 	String required_features;
@@ -53,7 +54,9 @@ private:
 	String requested_reference_space_types;
 	String reference_space_type;
 
+	// TODO maybe turn into a vector to support more then 2 controllers...
 	bool controllers_state[2];
+	Ref<XRPositionalTracker> controllers[2];
 	Size2 render_targetsize;
 
 	Transform3D _js_matrix_to_transform(float *p_js_matrix);
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);
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index bf8f7291be..902821da9c 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -450,6 +450,7 @@ void register_scene_types() {
 	GDREGISTER_CLASS(Camera3D);
 	GDREGISTER_CLASS(AudioListener3D);
 	GDREGISTER_CLASS(XRCamera3D);
+	GDREGISTER_VIRTUAL_CLASS(XRNode3D);
 	GDREGISTER_CLASS(XRController3D);
 	GDREGISTER_CLASS(XRAnchor3D);
 	GDREGISTER_CLASS(XROrigin3D);
diff --git a/servers/register_server_types.cpp b/servers/register_server_types.cpp
index 28cd8374c0..ea34134fe9 100644
--- a/servers/register_server_types.cpp
+++ b/servers/register_server_types.cpp
@@ -133,6 +133,7 @@ void register_server_types() {
 
 	GDREGISTER_VIRTUAL_CLASS(XRInterface);
 	GDREGISTER_CLASS(XRInterfaceExtension); // can't register this as virtual because we need a creation function for our extensions.
+	GDREGISTER_CLASS(XRPose);
 	GDREGISTER_CLASS(XRPositionalTracker);
 
 	GDREGISTER_CLASS(AudioStream);
diff --git a/servers/rendering/renderer_viewport.cpp b/servers/rendering/renderer_viewport.cpp
index b67b1cd806..11b0b4cf86 100644
--- a/servers/rendering/renderer_viewport.cpp
+++ b/servers/rendering/renderer_viewport.cpp
@@ -495,9 +495,6 @@ void RendererViewport::draw_viewports() {
 
 	if (XRServer::get_singleton() != nullptr) {
 		xr_interface = XRServer::get_singleton()->get_primary_interface();
-
-		// process all our active interfaces
-		XRServer::get_singleton()->_process();
 	}
 
 	if (Engine::get_singleton()->is_editor_hint()) {
diff --git a/servers/xr/xr_interface.cpp b/servers/xr/xr_interface.cpp
index bf54158905..db4a8cd04d 100644
--- a/servers/xr/xr_interface.cpp
+++ b/servers/xr/xr_interface.cpp
@@ -47,6 +47,8 @@ void XRInterface::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_render_target_size"), &XRInterface::get_render_target_size);
 	ClassDB::bind_method(D_METHOD("get_view_count"), &XRInterface::get_view_count);
 
+	ClassDB::bind_method(D_METHOD("trigger_haptic_pulse", "action_name", "tracker_name", "frequency", "amplitude", "duration_sec", "delay_sec"), &XRInterface::trigger_haptic_pulse);
+
 	ADD_GROUP("Interface", "interface_");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "interface_is_primary"), "set_primary", "is_primary");
 
@@ -63,13 +65,11 @@ void XRInterface::_bind_methods() {
 	BIND_ENUM_CONSTANT(XR_NONE);
 	BIND_ENUM_CONSTANT(XR_MONO);
 	BIND_ENUM_CONSTANT(XR_STEREO);
+	BIND_ENUM_CONSTANT(XR_QUAD);
+	BIND_ENUM_CONSTANT(XR_VR);
 	BIND_ENUM_CONSTANT(XR_AR);
 	BIND_ENUM_CONSTANT(XR_EXTERNAL);
 
-	BIND_ENUM_CONSTANT(EYE_MONO);
-	BIND_ENUM_CONSTANT(EYE_LEFT);
-	BIND_ENUM_CONSTANT(EYE_RIGHT);
-
 	BIND_ENUM_CONSTANT(XR_NORMAL_TRACKING);
 	BIND_ENUM_CONSTANT(XR_EXCESSIVE_MOTION);
 	BIND_ENUM_CONSTANT(XR_INSUFFICIENT_FEATURES);
@@ -114,9 +114,24 @@ int XRInterface::get_camera_feed_id() {
 }
 
 /** these are optional, so we want dummies **/
+PackedStringArray XRInterface::get_suggested_tracker_names() const {
+	PackedStringArray arr;
+
+	return arr;
+}
+
+PackedStringArray XRInterface::get_suggested_pose_names(const StringName &p_tracker_name) const {
+	PackedStringArray arr;
+
+	return arr;
+}
+
 XRInterface::TrackingStatus XRInterface::get_tracking_status() const {
 	return XR_UNKNOWN_TRACKING;
 }
 
 void XRInterface::notification(int p_what) {
 }
+
+void XRInterface::trigger_haptic_pulse(const String &p_action_name, const StringName &p_tracker_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec) {
+}
diff --git a/servers/xr/xr_interface.h b/servers/xr/xr_interface.h
index 534fa18d8a..9225334d6f 100644
--- a/servers/xr/xr_interface.h
+++ b/servers/xr/xr_interface.h
@@ -58,14 +58,10 @@ public:
 		XR_NONE = 0, /* no capabilities */
 		XR_MONO = 1, /* can be used with mono output */
 		XR_STEREO = 2, /* can be used with stereo output */
-		XR_AR = 4, /* offers a camera feed for AR */
-		XR_EXTERNAL = 8 /* renders to external device */
-	};
-
-	enum Eyes {
-		EYE_MONO, /* my son says we should call this EYE_CYCLOPS */
-		EYE_LEFT,
-		EYE_RIGHT
+		XR_QUAD = 4, /* can be used with quad output (not currently supported) */
+		XR_VR = 8, /* offers VR support */
+		XR_AR = 16, /* offers AR support */
+		XR_EXTERNAL = 32 /* renders to external device */
 	};
 
 	enum TrackingStatus { /* tracking status currently based on AR but we can start doing more with this for VR as well */
@@ -94,7 +90,12 @@ public:
 	virtual bool initialize() = 0; /* initialize this interface, if this has an HMD it becomes the primary interface */
 	virtual void uninitialize() = 0; /* deinitialize this interface */
 
+	/** input and output **/
+
+	virtual PackedStringArray get_suggested_tracker_names() const; /* return a list of likely/suggested tracker names */
+	virtual PackedStringArray get_suggested_pose_names(const StringName &p_tracker_name) const; /* return a list of likely/suggested action names for this tracker */
 	virtual TrackingStatus get_tracking_status() const; /* get the status of our current tracking */
+	virtual void trigger_haptic_pulse(const String &p_action_name, const StringName &p_tracker_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec = 0); /* trigger a haptic pulse */
 
 	/** specific to VR **/
 	// nothing yet
@@ -124,7 +125,6 @@ public:
 };
 
 VARIANT_ENUM_CAST(XRInterface::Capabilities);
-VARIANT_ENUM_CAST(XRInterface::Eyes);
 VARIANT_ENUM_CAST(XRInterface::TrackingStatus);
 
 #endif // !XR_INTERFACE_H
diff --git a/servers/xr/xr_interface_extension.cpp b/servers/xr/xr_interface_extension.cpp
index 7fdf90770d..9e97233a75 100644
--- a/servers/xr/xr_interface_extension.cpp
+++ b/servers/xr/xr_interface_extension.cpp
@@ -41,8 +41,6 @@ void XRInterfaceExtension::_bind_methods() {
 	GDVIRTUAL_BIND(_initialize);
 	GDVIRTUAL_BIND(_uninitialize);
 
-	GDVIRTUAL_BIND(_get_tracking_status);
-
 	GDVIRTUAL_BIND(_get_render_target_size);
 	GDVIRTUAL_BIND(_get_view_count);
 	GDVIRTUAL_BIND(_get_camera_transform);
@@ -54,6 +52,13 @@ void XRInterfaceExtension::_bind_methods() {
 	GDVIRTUAL_BIND(_process);
 	GDVIRTUAL_BIND(_notification, "what");
 
+	/** input and output **/
+
+	GDVIRTUAL_BIND(_get_suggested_tracker_names);
+	GDVIRTUAL_BIND(_get_suggested_pose_names, "tracker_name");
+	GDVIRTUAL_BIND(_get_tracking_status);
+	GDVIRTUAL_BIND(_trigger_haptic_pulse, "action_name", "tracker_name", "frequency", "amplitude", "duration_sec", "delay_sec");
+
 	// we don't have any properties specific to VR yet....
 
 	// but we do have properties specific to AR....
@@ -111,6 +116,22 @@ void XRInterfaceExtension::uninitialize() {
 	GDVIRTUAL_CALL(_uninitialize);
 }
 
+PackedStringArray XRInterfaceExtension::get_suggested_tracker_names() const {
+	PackedStringArray arr;
+
+	GDVIRTUAL_CALL(_get_suggested_tracker_names, arr);
+
+	return arr;
+}
+
+PackedStringArray XRInterfaceExtension::get_suggested_pose_names(const StringName &p_tracker_name) const {
+	PackedStringArray arr;
+
+	GDVIRTUAL_CALL(_get_suggested_pose_names, p_tracker_name, arr);
+
+	return arr;
+}
+
 XRInterface::TrackingStatus XRInterfaceExtension::get_tracking_status() const {
 	uint32_t status;
 
@@ -121,6 +142,10 @@ XRInterface::TrackingStatus XRInterfaceExtension::get_tracking_status() const {
 	return XR_UNKNOWN_TRACKING;
 }
 
+void XRInterfaceExtension::trigger_haptic_pulse(const String &p_action_name, const StringName &p_tracker_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec) {
+	GDVIRTUAL_CALL(_trigger_haptic_pulse, p_action_name, p_tracker_name, p_frequency, p_amplitude, p_duration_sec, p_delay_sec);
+}
+
 /** these will only be implemented on AR interfaces, so we want dummies for VR **/
 bool XRInterfaceExtension::get_anchor_detection_is_enabled() const {
 	bool enabled;
diff --git a/servers/xr/xr_interface_extension.h b/servers/xr/xr_interface_extension.h
index 3b7af4c0a2..50fc576c33 100644
--- a/servers/xr/xr_interface_extension.h
+++ b/servers/xr/xr_interface_extension.h
@@ -62,8 +62,17 @@ public:
 	GDVIRTUAL0R(bool, _initialize);
 	GDVIRTUAL0(_uninitialize);
 
+	/** input and output **/
+
+	virtual PackedStringArray get_suggested_tracker_names() const override; /* return a list of likely/suggested tracker names */
+	virtual PackedStringArray get_suggested_pose_names(const StringName &p_tracker_name) const override; /* return a list of likely/suggested action names for this tracker */
 	virtual TrackingStatus get_tracking_status() const override;
+	virtual void trigger_haptic_pulse(const String &p_action_name, const StringName &p_tracker_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec = 0) override;
+
+	GDVIRTUAL0RC(PackedStringArray, _get_suggested_tracker_names);
+	GDVIRTUAL1RC(PackedStringArray, _get_suggested_pose_names, const StringName &);
 	GDVIRTUAL0RC(uint32_t, _get_tracking_status);
+	GDVIRTUAL6(_trigger_haptic_pulse, const String &, const StringName &, double, double, double, double);
 
 	/** specific to VR **/
 	// nothing yet
diff --git a/servers/xr/xr_pose.cpp b/servers/xr/xr_pose.cpp
new file mode 100644
index 0000000000..0d05e62b46
--- /dev/null
+++ b/servers/xr/xr_pose.cpp
@@ -0,0 +1,110 @@
+/*************************************************************************/
+/*  xr_pose.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "xr_pose.h"
+
+#include "servers/xr_server.h"
+
+void XRPose::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_has_tracking_data", "has_tracking_data"), &XRPose::set_has_tracking_data);
+	ClassDB::bind_method(D_METHOD("get_has_tracking_data"), &XRPose::get_has_tracking_data);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "has_tracking_data"), "set_has_tracking_data", "get_has_tracking_data");
+
+	ClassDB::bind_method(D_METHOD("set_name", "name"), &XRPose::set_name);
+	ClassDB::bind_method(D_METHOD("get_name"), &XRPose::get_name);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "name"), "set_name", "get_name");
+
+	ClassDB::bind_method(D_METHOD("set_transform", "transform"), &XRPose::set_transform);
+	ClassDB::bind_method(D_METHOD("get_transform"), &XRPose::get_transform);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "transform"), "set_transform", "get_transform");
+	ClassDB::bind_method(D_METHOD("get_adjusted_transform"), &XRPose::get_adjusted_transform);
+
+	ClassDB::bind_method(D_METHOD("set_linear_velocity", "velocity"), &XRPose::set_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &XRPose::get_linear_velocity);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "linear_velocity"), "set_linear_velocity", "get_linear_velocity");
+
+	ClassDB::bind_method(D_METHOD("set_angular_velocity", "velocity"), &XRPose::set_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_angular_velocity"), &XRPose::get_angular_velocity);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "angular_velocity"), "set_angular_velocity", "get_angular_velocity");
+}
+
+void XRPose::set_has_tracking_data(const bool p_has_tracking_data) {
+	has_tracking_data = p_has_tracking_data;
+}
+bool XRPose::get_has_tracking_data() const {
+	return has_tracking_data;
+}
+
+void XRPose::set_name(const StringName &p_name) {
+	name = p_name;
+}
+
+StringName XRPose::get_name() const {
+	return name;
+}
+
+void XRPose::set_transform(const Transform3D p_transform) {
+	transform = p_transform;
+}
+
+Transform3D XRPose::get_transform() const {
+	return transform;
+}
+
+Transform3D XRPose::get_adjusted_transform() const {
+	Transform3D adjusted_transform = transform;
+
+	XRServer *xr_server = XRServer::get_singleton();
+	ERR_FAIL_NULL_V(xr_server, transform);
+
+	// apply world scale
+	adjusted_transform.origin *= xr_server->get_world_scale();
+
+	// apply reference frame
+	adjusted_transform = xr_server->get_reference_frame() * adjusted_transform;
+
+	return adjusted_transform;
+}
+
+void XRPose::set_linear_velocity(const Vector3 p_velocity) {
+	linear_velocity = p_velocity;
+}
+
+Vector3 XRPose::get_linear_velocity() const {
+	return linear_velocity;
+}
+
+void XRPose::set_angular_velocity(const Vector3 p_velocity) {
+	angular_velocity = p_velocity;
+}
+
+Vector3 XRPose::get_angular_velocity() const {
+	return angular_velocity;
+}
diff --git a/servers/xr/xr_pose.h b/servers/xr/xr_pose.h
new file mode 100644
index 0000000000..223e95ddfe
--- /dev/null
+++ b/servers/xr/xr_pose.h
@@ -0,0 +1,68 @@
+/*************************************************************************/
+/*  xr_pose.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef XR_POSE_H
+#define XR_POSE_H
+
+#include "core/object/ref_counted.h"
+
+class XRPose : public RefCounted {
+	GDCLASS(XRPose, RefCounted);
+
+public:
+private:
+	bool has_tracking_data = false;
+	StringName name;
+	Transform3D transform;
+	Vector3 linear_velocity;
+	Vector3 angular_velocity;
+
+protected:
+	static void _bind_methods();
+
+public:
+	void set_has_tracking_data(const bool p_has_tracking_data);
+	bool get_has_tracking_data() const;
+
+	void set_name(const StringName &p_name);
+	StringName get_name() const;
+
+	void set_transform(const Transform3D p_transform);
+	Transform3D get_transform() const;
+	Transform3D get_adjusted_transform() const;
+
+	void set_linear_velocity(const Vector3 p_velocity);
+	Vector3 get_linear_velocity() const;
+
+	void set_angular_velocity(const Vector3 p_velocity);
+	Vector3 get_angular_velocity() const;
+};
+
+#endif
diff --git a/servers/xr/xr_positional_tracker.cpp b/servers/xr/xr_positional_tracker.cpp
index e9383db941..1313a91172 100644
--- a/servers/xr/xr_positional_tracker.cpp
+++ b/servers/xr/xr_positional_tracker.cpp
@@ -37,29 +37,37 @@ void XRPositionalTracker::_bind_methods() {
 	BIND_ENUM_CONSTANT(TRACKER_HAND_LEFT);
 	BIND_ENUM_CONSTANT(TRACKER_HAND_RIGHT);
 
-	// this class is read only from GDScript, so we only have access to getters..
 	ClassDB::bind_method(D_METHOD("get_tracker_type"), &XRPositionalTracker::get_tracker_type);
-	ClassDB::bind_method(D_METHOD("get_tracker_id"), &XRPositionalTracker::get_tracker_id);
+	ClassDB::bind_method(D_METHOD("set_tracker_type", "type"), &XRPositionalTracker::set_tracker_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "type"), "set_tracker_type", "get_tracker_type");
+
 	ClassDB::bind_method(D_METHOD("get_tracker_name"), &XRPositionalTracker::get_tracker_name);
-	ClassDB::bind_method(D_METHOD("get_joy_id"), &XRPositionalTracker::get_joy_id);
-	ClassDB::bind_method(D_METHOD("is_tracking_orientation"), &XRPositionalTracker::is_tracking_orientation);
-	ClassDB::bind_method(D_METHOD("get_orientation"), &XRPositionalTracker::get_orientation);
-	ClassDB::bind_method(D_METHOD("is_tracking_position"), &XRPositionalTracker::is_tracking_position);
-	ClassDB::bind_method(D_METHOD("get_position"), &XRPositionalTracker::get_position);
+	ClassDB::bind_method(D_METHOD("set_tracker_name", "name"), &XRPositionalTracker::set_tracker_name);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "name"), "set_tracker_name", "get_tracker_name");
+
+	ClassDB::bind_method(D_METHOD("get_tracker_desc"), &XRPositionalTracker::get_tracker_desc);
+	ClassDB::bind_method(D_METHOD("set_tracker_desc", "description"), &XRPositionalTracker::set_tracker_desc);
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "description"), "set_tracker_desc", "get_tracker_desc");
+
 	ClassDB::bind_method(D_METHOD("get_tracker_hand"), &XRPositionalTracker::get_tracker_hand);
-	ClassDB::bind_method(D_METHOD("get_transform", "adjust_by_reference_frame"), &XRPositionalTracker::get_transform);
-	ClassDB::bind_method(D_METHOD("get_mesh"), &XRPositionalTracker::get_mesh);
-
-	// these functions we don't want to expose to normal users but do need to be callable from GDNative
-	ClassDB::bind_method(D_METHOD("_set_tracker_type", "type"), &XRPositionalTracker::set_tracker_type);
-	ClassDB::bind_method(D_METHOD("_set_tracker_name", "name"), &XRPositionalTracker::set_tracker_name);
-	ClassDB::bind_method(D_METHOD("_set_joy_id", "joy_id"), &XRPositionalTracker::set_joy_id);
-	ClassDB::bind_method(D_METHOD("_set_orientation", "orientation"), &XRPositionalTracker::set_orientation);
-	ClassDB::bind_method(D_METHOD("_set_rw_position", "rw_position"), &XRPositionalTracker::set_rw_position);
-	ClassDB::bind_method(D_METHOD("_set_mesh", "mesh"), &XRPositionalTracker::set_mesh);
+	ClassDB::bind_method(D_METHOD("set_tracker_hand", "hand"), &XRPositionalTracker::set_tracker_hand);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "hand", PROPERTY_HINT_ENUM, "Unknown,Left,Right"), "set_tracker_hand", "get_tracker_hand");
+
+	ClassDB::bind_method(D_METHOD("has_pose", "name"), &XRPositionalTracker::has_pose);
+	ClassDB::bind_method(D_METHOD("get_pose", "name"), &XRPositionalTracker::get_pose);
+	ClassDB::bind_method(D_METHOD("invalidate_pose", "name"), &XRPositionalTracker::invalidate_pose);
+	ClassDB::bind_method(D_METHOD("set_pose", "name", "transform", "linear_velocity", "angular_velocity"), &XRPositionalTracker::set_pose);
+	ADD_SIGNAL(MethodInfo("pose_changed", PropertyInfo(Variant::OBJECT, "pose", PROPERTY_HINT_RESOURCE_TYPE, "XRPose")));
+
+	ClassDB::bind_method(D_METHOD("get_input", "name"), &XRPositionalTracker::get_input);
+	ClassDB::bind_method(D_METHOD("set_input", "name", "value"), &XRPositionalTracker::set_input);
+	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, "vector")));
+
 	ClassDB::bind_method(D_METHOD("get_rumble"), &XRPositionalTracker::get_rumble);
 	ClassDB::bind_method(D_METHOD("set_rumble", "rumble"), &XRPositionalTracker::set_rumble);
-
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rumble"), "set_rumble", "get_rumble");
 };
 
@@ -67,13 +75,6 @@ void XRPositionalTracker::set_tracker_type(XRServer::TrackerType p_type) {
 	if (type != p_type) {
 		type = p_type;
 		hand = XRPositionalTracker::TRACKER_HAND_UNKNOWN;
-
-		XRServer *xr_server = XRServer::get_singleton();
-		ERR_FAIL_NULL(xr_server);
-
-		// get a tracker id for our type
-		// note if this is a controller this will be 3 or higher but we may change it later.
-		tracker_id = xr_server->get_free_tracker_id_for_type(p_type);
 	};
 };
 
@@ -81,7 +82,8 @@ XRServer::TrackerType XRPositionalTracker::get_tracker_type() const {
 	return type;
 };
 
-void XRPositionalTracker::set_tracker_name(const String &p_name) {
+void XRPositionalTracker::set_tracker_name(const StringName &p_name) {
+	// Note: this should not be changed after the tracker is registered with the XRServer!
 	name = p_name;
 };
 
@@ -89,85 +91,13 @@ StringName XRPositionalTracker::get_tracker_name() const {
 	return name;
 };
 
-int XRPositionalTracker::get_tracker_id() const {
-	return tracker_id;
-};
-
-void XRPositionalTracker::set_joy_id(int p_joy_id) {
-	joy_id = p_joy_id;
-};
-
-int XRPositionalTracker::get_joy_id() const {
-	return joy_id;
-};
-
-bool XRPositionalTracker::is_tracking_orientation() const {
-	return tracking_orientation;
-};
-
-void XRPositionalTracker::set_orientation(const Basis &p_orientation) {
-	_THREAD_SAFE_METHOD_
-
-	tracking_orientation = true; // obviously we have this
-	orientation = p_orientation;
-};
-
-Basis XRPositionalTracker::get_orientation() const {
-	_THREAD_SAFE_METHOD_
-
-	return orientation;
-};
-
-bool XRPositionalTracker::is_tracking_position() const {
-	return tracking_position;
-};
-
-void XRPositionalTracker::set_position(const Vector3 &p_position) {
-	_THREAD_SAFE_METHOD_
-
-	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL(xr_server);
-	real_t world_scale = xr_server->get_world_scale();
-	ERR_FAIL_COND(world_scale == 0);
-
-	tracking_position = true; // obviously we have this
-	rw_position = p_position / world_scale;
-};
-
-Vector3 XRPositionalTracker::get_position() const {
-	_THREAD_SAFE_METHOD_
-
-	XRServer *xr_server = XRServer::get_singleton();
-	ERR_FAIL_NULL_V(xr_server, rw_position);
-	real_t world_scale = xr_server->get_world_scale();
-
-	return rw_position * world_scale;
-};
-
-void XRPositionalTracker::set_rw_position(const Vector3 &p_rw_position) {
-	_THREAD_SAFE_METHOD_
-
-	tracking_position = true; // obviously we have this
-	rw_position = p_rw_position;
-};
-
-Vector3 XRPositionalTracker::get_rw_position() const {
-	_THREAD_SAFE_METHOD_
-
-	return rw_position;
-};
-
-void XRPositionalTracker::set_mesh(const Ref<Mesh> &p_mesh) {
-	_THREAD_SAFE_METHOD_
-
-	mesh = p_mesh;
-};
-
-Ref<Mesh> XRPositionalTracker::get_mesh() const {
-	_THREAD_SAFE_METHOD_
+void XRPositionalTracker::set_tracker_desc(const String &p_desc) {
+	description = p_desc;
+}
 
-	return mesh;
-};
+String XRPositionalTracker::get_tracker_desc() const {
+	return description;
+}
 
 XRPositionalTracker::TrackerHand XRPositionalTracker::get_tracker_hand() const {
 	return hand;
@@ -182,33 +112,98 @@ void XRPositionalTracker::set_tracker_hand(const XRPositionalTracker::TrackerHan
 		ERR_FAIL_COND((type != XRServer::TRACKER_CONTROLLER) && (p_hand != XRPositionalTracker::TRACKER_HAND_UNKNOWN));
 
 		hand = p_hand;
-		if (hand == XRPositionalTracker::TRACKER_HAND_LEFT) {
-			if (!xr_server->is_tracker_id_in_use_for_type(type, 1)) {
-				tracker_id = 1;
-			};
-		} else if (hand == XRPositionalTracker::TRACKER_HAND_RIGHT) {
-			if (!xr_server->is_tracker_id_in_use_for_type(type, 2)) {
-				tracker_id = 2;
-			};
-		};
 	};
 };
 
-Transform3D XRPositionalTracker::get_transform(bool p_adjust_by_reference_frame) const {
-	Transform3D new_transform;
+bool XRPositionalTracker::has_pose(const StringName &p_action_name) const {
+	return poses.has(p_action_name);
+}
 
-	new_transform.basis = get_orientation();
-	new_transform.origin = get_position();
+Ref<XRPose> XRPositionalTracker::get_pose(const StringName &p_action_name) const {
+	Ref<XRPose> pose;
 
-	if (p_adjust_by_reference_frame) {
-		XRServer *xr_server = XRServer::get_singleton();
-		ERR_FAIL_NULL_V(xr_server, new_transform);
+	if (poses.has(p_action_name)) {
+		pose = poses[p_action_name];
+	}
 
-		new_transform = xr_server->get_reference_frame() * new_transform;
-	};
+	return pose;
+}
 
-	return new_transform;
-};
+void XRPositionalTracker::invalidate_pose(const StringName &p_action_name) {
+	// only update this if we were tracking this pose
+	if (poses.has(p_action_name)) {
+		// We just set tracking data as invalid, we leave our current transform and velocity data as is so controllers don't suddenly jump to origin.
+		poses[p_action_name]->set_has_tracking_data(false);
+	}
+}
+
+void XRPositionalTracker::set_pose(const StringName &p_action_name, const Transform3D &p_transform, const Vector3 &p_linear_velocity, const Vector3 &p_angular_velocity) {
+	Ref<XRPose> new_pose;
+
+	new_pose.instantiate();
+	new_pose->set_name(p_action_name);
+	new_pose->set_has_tracking_data(true);
+	new_pose->set_transform(p_transform);
+	new_pose->set_linear_velocity(p_linear_velocity);
+	new_pose->set_angular_velocity(p_angular_velocity);
+
+	poses[p_action_name] = new_pose;
+	emit_signal("pose_changed", new_pose);
+
+	// TODO discuss whether we also want to create and emit an InputEventXRPose event
+}
+
+Variant XRPositionalTracker::get_input(const StringName &p_action_name) const {
+	if (inputs.has(p_action_name)) {
+		return inputs[p_action_name];
+	} else {
+		return Variant();
+	}
+}
+
+void XRPositionalTracker::set_input(const StringName &p_action_name, const Variant &p_value) {
+	bool changed = false;
+
+	// XR inputs
+
+	if (inputs.has(p_action_name)) {
+		changed = inputs[p_action_name] != p_value;
+	} else {
+		changed = true;
+	}
+
+	if (changed) {
+		// store the new value
+		inputs[p_action_name] = p_value;
+
+		// emit signals to let the rest of the world know
+		switch (p_value.get_type()) {
+			case Variant::BOOL: {
+				bool pressed = p_value;
+				if (pressed) {
+					emit_signal("button_pressed", p_action_name);
+				} else {
+					emit_signal("button_released", p_action_name);
+				}
+
+				// TODO discuss whether we also want to create and emit an InputEventXRButton event
+			} break;
+			case Variant::FLOAT: {
+				emit_signal("input_value_changed", p_action_name, p_value);
+
+				// TODO discuss whether we also want to create and emit an InputEventXRValue event
+			} break;
+			case Variant::VECTOR2: {
+				emit_signal("input_axis_changed", p_action_name, p_value);
+
+				// TODO discuss whether we also want to create and emit an InputEventXRAxis event
+			} break;
+			default: {
+				// ???
+			} break;
+		}
+	}
+}
 
 real_t XRPositionalTracker::get_rumble() const {
 	return rumble;
@@ -225,10 +220,6 @@ void XRPositionalTracker::set_rumble(real_t p_rumble) {
 XRPositionalTracker::XRPositionalTracker() {
 	type = XRServer::TRACKER_UNKNOWN;
 	name = "Unknown";
-	joy_id = -1;
-	tracker_id = 0;
-	tracking_orientation = false;
-	tracking_position = false;
 	hand = TRACKER_HAND_UNKNOWN;
 	rumble = 0.0;
 };
diff --git a/servers/xr/xr_positional_tracker.h b/servers/xr/xr_positional_tracker.h
index 5577582929..69eb105b5a 100644
--- a/servers/xr/xr_positional_tracker.h
+++ b/servers/xr/xr_positional_tracker.h
@@ -33,6 +33,7 @@
 
 #include "core/os/thread_safe.h"
 #include "scene/resources/mesh.h"
+#include "servers/xr/xr_pose.h"
 #include "servers/xr_server.h"
 
 /**
@@ -57,14 +58,14 @@ public:
 private:
 	XRServer::TrackerType type; // type of tracker
 	StringName name; // (unique) name of the tracker
-	int tracker_id; // tracker index id that is unique per type
+	String description; // description of the tracker, this is interface dependent, for OpenXR this will be the interaction profile bound for to the tracker
+	TrackerHand hand; // if known, the hand this tracker is held in
+
+	Map<StringName, Ref<XRPose>> poses;
+	Map<StringName, Variant> inputs;
+
 	int joy_id; // if we also have a related joystick entity, the id of the joystick
-	bool tracking_orientation; // do we track orientation?
-	Basis orientation; // our orientation
-	bool tracking_position; // do we track position?
-	Vector3 rw_position; // our position "in the real world, so without world_scale applied"
 	Ref<Mesh> mesh; // when available, a mesh that can be used to render this tracker
-	TrackerHand hand; // if known, the hand this tracker is held in
 	real_t rumble; // rumble strength, 0.0 is off, 1.0 is maximum, note that we only record here, xr_interface is responsible for execution
 
 protected:
@@ -73,27 +74,24 @@ protected:
 public:
 	void set_tracker_type(XRServer::TrackerType p_type);
 	XRServer::TrackerType get_tracker_type() const;
-	void set_tracker_name(const String &p_name);
+	void set_tracker_name(const StringName &p_name);
 	StringName get_tracker_name() const;
-	int get_tracker_id() const;
-	void set_joy_id(int p_joy_id);
-	int get_joy_id() const;
-	bool is_tracking_orientation() const;
-	void set_orientation(const Basis &p_orientation);
-	Basis get_orientation() const;
-	bool is_tracking_position() const;
-	void set_position(const Vector3 &p_position); // set position with world_scale applied
-	Vector3 get_position() const; // get position with world_scale applied
-	void set_rw_position(const Vector3 &p_rw_position);
-	Vector3 get_rw_position() const;
+	void set_tracker_desc(const String &p_desc);
+	String get_tracker_desc() const;
 	XRPositionalTracker::TrackerHand get_tracker_hand() const;
 	void set_tracker_hand(const XRPositionalTracker::TrackerHand p_hand);
+
+	bool has_pose(const StringName &p_action_name) const;
+	Ref<XRPose> get_pose(const StringName &p_action_name) const;
+	void invalidate_pose(const StringName &p_action_name);
+	void set_pose(const StringName &p_action_name, const Transform3D &p_transform, const Vector3 &p_linear_velocity, const Vector3 &p_angular_velocity);
+
+	Variant get_input(const StringName &p_action_name) const;
+	void set_input(const StringName &p_action_name, const Variant &p_value);
+
+	// TODO replace by new implementation
 	real_t get_rumble() const;
 	void set_rumble(real_t p_rumble);
-	void set_mesh(const Ref<Mesh> &p_mesh);
-	Ref<Mesh> get_mesh() const;
-
-	Transform3D get_transform(bool p_adjust_by_reference_frame) const;
 
 	XRPositionalTracker();
 	~XRPositionalTracker() {}
diff --git a/servers/xr_server.cpp b/servers/xr_server.cpp
index 780bd10fc5..5d6f5be20d 100644
--- a/servers/xr_server.cpp
+++ b/servers/xr_server.cpp
@@ -54,10 +54,11 @@ void XRServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_interface", "idx"), &XRServer::get_interface);
 	ClassDB::bind_method(D_METHOD("get_interfaces"), &XRServer::get_interfaces);
 	ClassDB::bind_method(D_METHOD("find_interface", "name"), &XRServer::find_interface);
-	ClassDB::bind_method(D_METHOD("get_tracker_count"), &XRServer::get_tracker_count);
-	ClassDB::bind_method(D_METHOD("get_tracker", "idx"), &XRServer::get_tracker);
+
 	ClassDB::bind_method(D_METHOD("add_tracker", "tracker"), &XRServer::add_tracker);
 	ClassDB::bind_method(D_METHOD("remove_tracker", "tracker"), &XRServer::remove_tracker);
+	ClassDB::bind_method(D_METHOD("get_trackers", "tracker_types"), &XRServer::get_trackers);
+	ClassDB::bind_method(D_METHOD("get_tracker", "tracker_name"), &XRServer::get_tracker);
 
 	ClassDB::bind_method(D_METHOD("get_primary_interface"), &XRServer::get_primary_interface);
 	ClassDB::bind_method(D_METHOD("set_primary_interface", "interface"), &XRServer::set_primary_interface);
@@ -68,6 +69,7 @@ void XRServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_last_commit_usec"), &XRServer::get_last_commit_usec);
 	ClassDB::bind_method(D_METHOD("get_last_frame_usec"), &XRServer::get_last_frame_usec);
 
+	BIND_ENUM_CONSTANT(TRACKER_HEAD);
 	BIND_ENUM_CONSTANT(TRACKER_CONTROLLER);
 	BIND_ENUM_CONSTANT(TRACKER_BASESTATION);
 	BIND_ENUM_CONSTANT(TRACKER_ANCHOR);
@@ -82,8 +84,9 @@ void XRServer::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("interface_added", PropertyInfo(Variant::STRING_NAME, "interface_name")));
 	ADD_SIGNAL(MethodInfo("interface_removed", PropertyInfo(Variant::STRING_NAME, "interface_name")));
 
-	ADD_SIGNAL(MethodInfo("tracker_added", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type"), PropertyInfo(Variant::INT, "id")));
-	ADD_SIGNAL(MethodInfo("tracker_removed", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type"), PropertyInfo(Variant::INT, "id")));
+	ADD_SIGNAL(MethodInfo("tracker_added", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type")));
+	ADD_SIGNAL(MethodInfo("tracker_updated", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type")));
+	ADD_SIGNAL(MethodInfo("tracker_removed", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type")));
 };
 
 double XRServer::get_world_scale() const {
@@ -224,106 +227,121 @@ Array XRServer::get_interfaces() const {
 	return ret;
 };
 
-/*
-	A little extra info on the tracker ids, these are unique per tracker type so we get some consistency in recognising our trackers, specifically controllers.
-
-	The first controller that is turned of will get ID 1, the second will get ID 2, etc.
-	The magic happens when one of the controllers is turned off, say controller 1 turns off, controller 2 will remain controller 2, controller 3 will remain controller 3.
-	If controller number 1 is turned on again it again gets ID 1 unless another new controller was turned on since.
-
-	The most likely scenario however is a controller that runs out of battery and another controller being used to replace it.
-	Because the controllers are often linked to physical objects, say you're holding a shield in controller 1, your left hand, and a gun in controller 2, your right hand, and controller 1 dies:
-	- using our tracker index would suddenly make the gun disappear and the shield jump into your right hand because controller 2 becomes controller 1.
-	- using this approach the shield disappears or is no longer tracked, but the gun stays firmly in your right hand because that is still controller 2, further more, if controller 1 is replaced the shield will return.
-*/
-
-bool XRServer::is_tracker_id_in_use_for_type(TrackerType p_tracker_type, int p_tracker_id) const {
-	for (int i = 0; i < trackers.size(); i++) {
-		if (trackers[i]->get_tracker_type() == p_tracker_type && trackers[i]->get_tracker_id() == p_tracker_id) {
-			return true;
-		};
-	};
-
-	// all good
-	return false;
+Ref<XRInterface> XRServer::get_primary_interface() const {
+	return primary_interface;
 };
 
-int XRServer::get_free_tracker_id_for_type(TrackerType p_tracker_type) {
-	// We start checking at 1, 0 means that it's not a controller..
-	// Note that for controller we reserve:
-	// - 1 for the left hand controller and
-	// - 2 for the right hand controller
-	// so we start at 3 :)
-	int tracker_id = p_tracker_type == XRServer::TRACKER_CONTROLLER ? 3 : 1;
-
-	while (is_tracker_id_in_use_for_type(p_tracker_type, tracker_id)) {
-		// try the next one
-		tracker_id++;
-	};
+void XRServer::set_primary_interface(const Ref<XRInterface> &p_primary_interface) {
+	if (p_primary_interface.is_null()) {
+		print_verbose("XR: Clearing primary interface");
+		primary_interface.unref();
+	} else {
+		primary_interface = p_primary_interface;
 
-	return tracker_id;
+		print_verbose("XR: Primary interface set to: " + primary_interface->get_name());
+	}
 };
 
 void XRServer::add_tracker(Ref<XRPositionalTracker> p_tracker) {
 	ERR_FAIL_COND(p_tracker.is_null());
 
-	trackers.push_back(p_tracker);
-	emit_signal(SNAME("tracker_added"), p_tracker->get_tracker_name(), p_tracker->get_tracker_type(), p_tracker->get_tracker_id());
+	StringName tracker_name = p_tracker->get_tracker_name();
+	if (trackers.has(tracker_name)) {
+		if (trackers[tracker_name] != p_tracker) {
+			// We already have a tracker with this name, we're going to replace it
+			trackers[tracker_name] = p_tracker;
+			emit_signal(SNAME("tracker_updated"), tracker_name, p_tracker->get_tracker_type());
+		}
+	} else {
+		trackers[tracker_name] = p_tracker;
+		emit_signal(SNAME("tracker_added"), tracker_name, p_tracker->get_tracker_type());
+	}
 };
 
 void XRServer::remove_tracker(Ref<XRPositionalTracker> p_tracker) {
 	ERR_FAIL_COND(p_tracker.is_null());
 
-	int idx = -1;
-	for (int i = 0; i < trackers.size(); i++) {
-		if (trackers[i] == p_tracker) {
-			idx = i;
-			break;
-		};
-	};
+	StringName tracker_name = p_tracker->get_tracker_name();
+	if (trackers.has(tracker_name)) {
+		// we send the signal right before removing it
+		emit_signal(SNAME("tracker_removed"), p_tracker->get_tracker_name(), p_tracker->get_tracker_type());
 
-	ERR_FAIL_COND(idx == -1);
-
-	emit_signal(SNAME("tracker_removed"), p_tracker->get_tracker_name(), p_tracker->get_tracker_type(), p_tracker->get_tracker_id());
-	trackers.remove(idx);
+		// and remove it
+		trackers.erase(tracker_name);
+	}
 };
 
-int XRServer::get_tracker_count() const {
-	return trackers.size();
-};
+Dictionary XRServer::get_trackers(int p_tracker_types) {
+	Dictionary res;
+
+	for (int i = 0; i < trackers.size(); i++) {
+		Ref<XRPositionalTracker> tracker = trackers.get_value_at_index(i);
+		if (tracker.is_valid() && (tracker->get_tracker_type() & p_tracker_types) != 0) {
+			res[tracker->get_tracker_name()] = tracker;
+		}
+	}
 
-Ref<XRPositionalTracker> XRServer::get_tracker(int p_index) const {
-	ERR_FAIL_INDEX_V(p_index, trackers.size(), Ref<XRPositionalTracker>());
+	return res;
+}
 
-	return trackers[p_index];
+Ref<XRPositionalTracker> XRServer::get_tracker(const StringName &p_name) const {
+	if (trackers.has(p_name)) {
+		return trackers[p_name];
+	} else {
+		// tracker hasn't been registered yet, which is fine, no need to spam the error log...
+		return Ref<XRPositionalTracker>();
+	}
 };
 
-Ref<XRPositionalTracker> XRServer::find_by_type_and_id(TrackerType p_tracker_type, int p_tracker_id) const {
-	ERR_FAIL_COND_V(p_tracker_id == 0, Ref<XRPositionalTracker>());
+PackedStringArray XRServer::get_suggested_tracker_names() const {
+	PackedStringArray arr;
 
-	for (int i = 0; i < trackers.size(); i++) {
-		if (trackers[i]->get_tracker_type() == p_tracker_type && trackers[i]->get_tracker_id() == p_tracker_id) {
-			return trackers[i];
-		};
-	};
+	for (int i = 0; i < interfaces.size(); i++) {
+		Ref<XRInterface> interface = interfaces[i];
+		PackedStringArray interface_arr = interface->get_suggested_tracker_names();
+		for (int a = 0; a < interface_arr.size(); a++) {
+			if (!arr.has(interface_arr[a])) {
+				arr.push_back(interface_arr[a]);
+			}
+		}
+	}
 
-	return Ref<XRPositionalTracker>();
-};
+	if (arr.size() == 0) {
+		// no suggestions from our tracker? include our defaults
+		arr.push_back(String("head"));
+		arr.push_back(String("left_hand"));
+		arr.push_back(String("right_hand"));
+	}
 
-Ref<XRInterface> XRServer::get_primary_interface() const {
-	return primary_interface;
-};
+	return arr;
+}
 
-void XRServer::set_primary_interface(const Ref<XRInterface> &p_primary_interface) {
-	if (p_primary_interface.is_null()) {
-		print_verbose("XR: Clearing primary interface");
-		primary_interface.unref();
-	} else {
-		primary_interface = p_primary_interface;
+PackedStringArray XRServer::get_suggested_pose_names(const StringName &p_tracker_name) const {
+	PackedStringArray arr;
 
-		print_verbose("XR: Primary interface set to: " + primary_interface->get_name());
+	for (int i = 0; i < interfaces.size(); i++) {
+		Ref<XRInterface> interface = interfaces[i];
+		PackedStringArray interface_arr = interface->get_suggested_pose_names(p_tracker_name);
+		for (int a = 0; a < interface_arr.size(); a++) {
+			if (!arr.has(interface_arr[a])) {
+				arr.push_back(interface_arr[a]);
+			}
+		}
 	}
-};
+
+	if (arr.size() == 0) {
+		// no suggestions from our tracker? include our defaults
+		arr.push_back(String("default"));
+
+		if ((p_tracker_name == "left_hand") || (p_tracker_name == "right_hand")) {
+			arr.push_back(String("aim"));
+			arr.push_back(String("grip"));
+			arr.push_back(String("skeleton"));
+		}
+	}
+
+	return arr;
+}
 
 uint64_t XRServer::get_last_process_usec() {
 	return last_process_usec;
@@ -373,8 +391,9 @@ XRServer::~XRServer() {
 		interfaces.remove(0);
 	}
 
+	// TODO pretty sure there is a clear function or something...
 	while (trackers.size() > 0) {
-		trackers.remove(0);
+		trackers.erase(trackers.get_key_at_index(0));
 	}
 
 	singleton = nullptr;
diff --git a/servers/xr_server.h b/servers/xr_server.h
index 6d07263755..48d73cac9a 100644
--- a/servers/xr_server.h
+++ b/servers/xr_server.h
@@ -60,9 +60,10 @@ class XRServer : public Object {
 
 public:
 	enum TrackerType {
-		TRACKER_CONTROLLER = 0x01, /* tracks a controller */
-		TRACKER_BASESTATION = 0x02, /* tracks location of a base station */
-		TRACKER_ANCHOR = 0x04, /* tracks an anchor point, used in AR to track a real live location */
+		TRACKER_HEAD = 0x01, /* tracks the position of the players head (or in case of handheld AR, location of the phone) */
+		TRACKER_CONTROLLER = 0x02, /* tracks a controller */
+		TRACKER_BASESTATION = 0x04, /* tracks location of a base station */
+		TRACKER_ANCHOR = 0x08, /* tracks an anchor point, used in AR to track a real live location */
 		TRACKER_UNKNOWN = 0x80, /* unknown tracker */
 
 		TRACKER_ANY_KNOWN = 0x7f, /* all except unknown */
@@ -77,7 +78,7 @@ public:
 
 private:
 	Vector<Ref<XRInterface>> interfaces;
-	Vector<Ref<XRPositionalTracker>> trackers;
+	Dictionary trackers;
 
 	Ref<XRInterface> primary_interface; /* we'll identify one interface as primary, this will be used by our viewports */
 
@@ -164,13 +165,17 @@ public:
 		Our trackers are objects that expose the orientation and position of physical devices such as controller, anchor points, etc.
 		They are created and managed by our active AR/VR interfaces.
 	*/
-	bool is_tracker_id_in_use_for_type(TrackerType p_tracker_type, int p_tracker_id) const;
-	int get_free_tracker_id_for_type(TrackerType p_tracker_type);
 	void add_tracker(Ref<XRPositionalTracker> p_tracker);
 	void remove_tracker(Ref<XRPositionalTracker> p_tracker);
-	int get_tracker_count() const;
-	Ref<XRPositionalTracker> get_tracker(int p_index) const;
-	Ref<XRPositionalTracker> find_by_type_and_id(TrackerType p_tracker_type, int p_tracker_id) const;
+	Dictionary get_trackers(int p_tracker_types);
+	Ref<XRPositionalTracker> get_tracker(const StringName &p_name) const;
+
+	/*
+		We don't know which trackers and actions will existing during runtime but we can request suggested names from our interfaces to help our IDE UI.
+	*/
+	PackedStringArray get_suggested_tracker_names() const;
+	PackedStringArray get_suggested_pose_names(const StringName &p_tracker_name) const;
+	// Q: Should we add get_suggested_input_names and get_suggested_haptic_names even though we don't use them for the IDE?
 
 	uint64_t get_last_process_usec();
 	uint64_t get_last_commit_usec();