Modified solution to only enable position and/or rotation in tracking state if position and/or rotation actions have a resolved control that could drive input. Additionally fixed so that ignoreTrackingState == true, doesn't reset to identity, but preserve the configured transform of the associated GameObject.

Author: ekcoh

Packages/com.unity.inputsystem/InputSystem/Plugins/XR/TrackedPoseDriver.cs

@@ -308,7 +308,7 @@ void BindTrackingState()
             }
         }
 
-        private void RenameAndEnable(InputAction action, string name)
+        private static void RenameAndEnable(InputAction action, string name)
         {
 #if UNITY_EDITOR
             Editor.InputExitPlayModeAnalytic.suppress = true;
@@ -469,12 +469,17 @@ protected void UpdateCallback()
             if (m_IsFirstUpdate)
             {
                 // Update current input values if this is the first update since becoming enabled
-                // since the performed callbacks may not have been executed
-                if (m_PositionInput.action != null)
+                // since the performed callbacks may not have been executed. In case there is no bound control
+                // we preserve current transform by extracting transform values as initial values instead.
+                if (HasResolvedControl(m_PositionInput.action))
                     m_CurrentPosition = m_PositionInput.action.ReadValue<Vector3>();
+                else
+                    m_CurrentPosition = transform.localPosition;
 
-                if (m_RotationInput.action != null)
+                if (HasResolvedControl(m_RotationInput.action))
                     m_CurrentRotation = m_RotationInput.action.ReadValue<Quaternion>();
+                else
+                    m_CurrentRotation = transform.localRotation;
 
                 ReadTrackingState();
 
@@ -501,70 +506,28 @@ void ReadTrackingState()
             {
                 // Treat an Input Action Reference with no reference the same as
                 // an enabled Input Action with no authored bindings, and allow driving the Transform pose.
-                var positionInputAction = m_PositionInput.action;
-                var hasPositionInputActionWithBindings =
-                    positionInputAction != null && positionInputAction.m_BindingsCount > 0;
-
-                var rotationInputAction = m_RotationInput.action;
-                var hasRotationInputActionWithBindings =
-                    rotationInputAction != null && rotationInputAction.m_BindingsCount > 0;
+                var hasPositionInputActionWithBindings = HasResolvedControl(positionInput.action);
+                var hasRotationInputActionWithBindings = HasResolvedControl(rotationInput.action);
 
                 // Check if we have transform and rotation controls to drive the pose.
                 if (hasPositionInputActionWithBindings && hasRotationInputActionWithBindings)
-                {
                     m_CurrentTrackingState = TrackingStates.Position | TrackingStates.Rotation;
-                }
                 else if (hasPositionInputActionWithBindings)
-                {
                     m_CurrentTrackingState = TrackingStates.Position;
-                }
                 else if (hasRotationInputActionWithBindings)
-                {
                     m_CurrentTrackingState = TrackingStates.Rotation;
-                }
                 else
-                {
                     m_CurrentTrackingState = TrackingStates.None;
-                }
-                return;
             }
-
-            // Grab state.
-            var actionMap = trackingStateAction.GetOrCreateActionMap();
-            actionMap.ResolveBindingsIfNecessary();
-            var state = actionMap.m_State;
-
-            // Get list of resolved controls to determine if a device actually has tracking state.
-            var hasResolvedControl = false;
-            if (state != null)
+            else if (HasResolvedControl(trackingStateAction))
             {
-                var actionIndex = trackingStateAction.m_ActionIndexInState;
-                var totalBindingCount = state.totalBindingCount;
-                for (var i = 0; i < totalBindingCount; ++i)
-                {
-                    unsafe
-                    {
-                        ref var bindingState = ref state.bindingStates[i];
-                        if (bindingState.actionIndex != actionIndex)
-                            continue;
-                        if (bindingState.isComposite)
-                            continue;
-
-                        if (bindingState.controlCount > 0)
-                        {
-                            hasResolvedControl = true;
-                            break;
-                        }
-                    }
-                }
+                // Retain the current value if there is no resolved binding.
+                // Since the field initializes to allowing position and rotation,
+                // this allows for driving the Transform pose always when the device
+                // doesn't support reporting the tracking state.
+                if (HasResolvedControl(trackingStateAction))
+                    m_CurrentTrackingState = (TrackingStates)trackingStateAction.ReadValue<int>();
             }
-
-            // Retain the current value if there is no resolved binding.
-            // Since the field initializes to allowing position and rotation,
-            // this allows for driving the Transform pose always when the device
-            // doesn't support reporting the tracking state.
-            if (hasResolvedControl)
-                m_CurrentTrackingState = (TrackingStates)trackingStateAction.ReadValue<int>();
         }
 
         /// <summary>
@@ -610,6 +573,8 @@ protected virtual void PerformUpdate()
         /// <param name="newRotation">The new local rotation to possibly set.</param>
         protected virtual void SetLocalTransform(Vector3 newPosition, Quaternion newRotation)
         {
+            // Note that tracking state will be set to reflect whether the position and/or rotation
+            // actions can provide applicable values.
             var positionValid = m_IgnoreTrackingState || (m_CurrentTrackingState & TrackingStates.Position) != 0;
             var rotationValid = m_IgnoreTrackingState || (m_CurrentTrackingState & TrackingStates.Rotation) != 0;
 
@@ -641,6 +606,40 @@ bool HasStereoCamera(out Camera cameraComponent)
             return TryGetComponent(out cameraComponent) && cameraComponent.stereoEnabled;
         }
 
+        // Evaluates whether the given action has at least one resolved control and may generate input.
+        private static bool HasResolvedControl(InputAction action)
+        {
+            // Action cannot have controls if null.
+            if (action == null)
+                return false;
+
+            // Attempt to grab state and resolve bindings unless already resolved.
+            var actionMap = action.GetOrCreateActionMap();
+            actionMap.ResolveBindingsIfNecessary();
+            var state = actionMap.m_State;
+            if (state == null)
+                return false;
+
+            // Get list of resolved controls to determine if a device actually has a tracking state.
+            var actionIndex = action.m_ActionIndexInState;
+            var totalBindingCount = state.totalBindingCount;
+            for (var i = 0; i < totalBindingCount; ++i)
+            {
+                unsafe
+                {
+                    ref var bindingState = ref state.bindingStates[i];
+                    if (bindingState.actionIndex != actionIndex)
+                        continue;
+                    if (bindingState.isComposite)
+                        continue;
+                    if (bindingState.controlCount > 0)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
         #region DEPRECATED
 
         // Disable warnings that these fields are never assigned to. They are set during Unity deserialization and migrated.