Move FaceUser/FaceAwayFromUser to a TransformConstraint

Also updated and implemented new tests.

Author: MenelvagorMilsom

Assets/MixedRealityToolkit.SDK/Experimental/Features/Input/Handlers/ObjectManipulator.cs

@@ -25,8 +25,6 @@ public class ObjectManipulator : MonoBehaviour, IMixedRealityPointerHandler, IMi
         #region Public Enums
         public enum RotateInOneHandType
         {
-            FaceUser,
-            FaceAwayFromUser,
             MaintainOriginalRotation,
             RotateAboutObjectCenter,
             RotateAboutGrabPoint
@@ -283,15 +281,12 @@ public PointerData(IMixedRealityPointer pointer, Vector3 worldGrabPoint) : this(
         }
 
         private Dictionary<uint, PointerData> pointerIdToPointerMap = new Dictionary<uint, PointerData>();
-        private Quaternion objectToHandRotation;
         private Quaternion objectToGripRotation;
         private bool isNearManipulation;
         private bool isManipulationStarted;
 
         private Rigidbody rigidBody;
         private bool wasKinematic = false;
-        
-        private Quaternion hostWorldRotationOnManipulationStart;
 
         private ConstraintManager constraints;
 
@@ -573,15 +568,6 @@ private void HandleOneHandMoveStarted()
             PointerData pointerData = GetFirstPointer();
             IMixedRealityPointer pointer = pointerData.pointer;
 
-            // cache objects rotation on start to have a reference for constraint calculations
-            // if we don't cache this on manipulation start the near rotation might drift off the hand
-            // over time
-            hostWorldRotationOnManipulationStart = HostTransform.rotation;
-
-            // Calculate relative transform from object to hand.
-            Quaternion worldToPalmRotation = Quaternion.Inverse(pointer.Rotation);
-            objectToHandRotation = worldToPalmRotation * HostTransform.rotation;
-
             // Calculate relative transform from object to grip.
             Quaternion gripRotation;
             TryGetGripRotation(pointer, out gripRotation);
@@ -609,19 +595,6 @@ private void HandleOneHandMoveUpdated()
                 case RotateInOneHandType.MaintainOriginalRotation:
                     targetTransform.Rotation = HostTransform.rotation;
                     break;
-                case RotateInOneHandType.FaceUser:
-                {
-                    Vector3 directionToTarget = pointerData.GrabPoint - CameraCache.Main.transform.position;
-                    // Vector3 directionToTarget = HostTransform.position - CameraCache.Main.transform.position;
-                    targetTransform.Rotation = Quaternion.LookRotation(-directionToTarget);
-                    break;
-                }
-                case RotateInOneHandType.FaceAwayFromUser:
-                {
-                    Vector3 directionToTarget = pointerData.GrabPoint - CameraCache.Main.transform.position;
-                    targetTransform.Rotation = Quaternion.LookRotation(directionToTarget);
-                    break;
-                }
                 case RotateInOneHandType.RotateAboutObjectCenter:
                 case RotateInOneHandType.RotateAboutGrabPoint:
                     Quaternion gripRotation;

Assets/MixedRealityToolkit.SDK/Experimental/Features/Utilities/Migration/ObjectManipulatorMigrationHandler.cs

@@ -142,11 +142,27 @@ private void MigrateOneHandRotationModes(ref ObjectManipulator objManip, Manipul
                         break;
                     }
                 case ManipulationHandler.RotateInOneHandType.FaceUser:
-                    newMode = ObjectManipulator.RotateInOneHandType.FaceUser;
-                    break;
+                    {
+                        newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+                        var rotConstraint = objManip.EnsureComponent<FaceUserConstraint>();
+                        rotConstraint.TargetTransform = objManip.HostTransform;
+                        rotConstraint.HandType = ManipulationHandFlags.OneHanded;
+                        rotConstraint.ProximityType = proximity;
+                        rotConstraint.FaceAway = false;
+                        break;
+                    }
                 case ManipulationHandler.RotateInOneHandType.FaceAwayFromUser:
-                    newMode = ObjectManipulator.RotateInOneHandType.FaceAwayFromUser;
-                    break;
+                    {
+                        newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+                        var rotConstraint = objManip.EnsureComponent<FaceUserConstraint>();
+                        rotConstraint.TargetTransform = objManip.HostTransform;
+                        rotConstraint.HandType = ManipulationHandFlags.OneHanded;
+                        rotConstraint.ProximityType = proximity;
+                        rotConstraint.FaceAway = true;
+                        break;
+                    }
                 case ManipulationHandler.RotateInOneHandType.MaintainOriginalRotation:
                     newMode = ObjectManipulator.RotateInOneHandType.MaintainOriginalRotation;
                     break;

Assets/MixedRealityToolkit.SDK/Features/Input/Handlers/Constraints/FaceUserConstraint.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Utilities;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.UI
+{
+    /// <summary>
+    /// Component for fixing the rotation of a manipulated object such that
+    /// it always faces or faces away from the user
+    /// </summary>
+    public class FaceUserConstraint : TransformConstraint
+    {
+        #region Properties
+
+        [SerializeField]
+        [Tooltip("Option to use this constraint to face away from the user")]
+        private bool faceAway = false;
+
+        /// <summary>
+        /// If true, this will constrain rotation to face away from the user
+        /// </summary>
+        public bool FaceAway
+        {
+            get => faceAway;
+            set => faceAway = value;
+        }
+
+        public override TransformFlags ConstraintType => TransformFlags.Rotate;
+
+        #endregion Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Updates an rotation so that its facing the camera
+        /// </summary>
+        public override void ApplyConstraint(ref MixedRealityTransform transform)
+        {
+            Vector3 directionToTarget = transform.Position - CameraCache.Main.transform.position;
+            transform.Rotation = Quaternion.LookRotation(faceAway ? -directionToTarget : directionToTarget);
+        }
+
+        #endregion Public Methods
+    }
+}

Assets/MixedRealityToolkit.SDK/Features/Input/Handlers/Constraints/FaceUserConstraint.cs.meta

@@ -7,8 +7,7 @@
 namespace Microsoft.MixedReality.Toolkit.UI
 {
     /// <summary>
-    /// Component for limiting the rotation of a manipulated object relative to the user
-    /// or BoundingBox
+    /// Component for fixing the rotation of a manipulated object relative to the user
     /// </summary>
     public class FixedRotationToUserConstraint : TransformConstraint
     {
@@ -31,8 +30,8 @@ public override void Initialize(MixedRealityPose worldPose)
         }
 
         /// <summary>
-        /// Removes rotation about given axis if its flag is found
-        /// in ConstraintOnRotation
+        /// Updates the objects rotation so that the rotation relative to the user
+        /// is fixed
         /// </summary>
         public override void ApplyConstraint(ref MixedRealityTransform transform)
         {

Assets/MixedRealityToolkit.SDK/Features/Input/Handlers/Constraints/FixedRotationToUserConstraint.cs

@@ -645,7 +645,7 @@ public IEnumerator ConstrainByNumberOfHands()
             yield return new WaitForFixedUpdate();
             yield return null;
 
-            const int numHandSteps = 1;
+            const int numHandSteps = 10;
 
             TestHand leftHand = new TestHand(Handedness.Left);
             TestHand rightHand = new TestHand(Handedness.Right);
@@ -685,8 +685,7 @@ public IEnumerator ConstrainByNumberOfHands()
         public IEnumerator ConstrainByProximity()
         {
             TestUtilities.PlayspaceToOriginLookingForward();
-
-            // set up cube with manipulation handler
+            
             var testObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
             testObject.transform.localScale = Vector3.one * 0.2f;
             Vector3 originalPosition = Vector3.forward;
@@ -753,6 +752,67 @@ public IEnumerator ConstrainByProximity()
             TestUtilities.AssertNotAboutEqual(originalRotation, testObject.transform.rotation, "Rotation should not be equal for far interaction");
             TestUtilities.AssertAboutEqual(originalPosition, testObject.transform.position, "Position should be equal for far interaction");
         }
+
+        /// <summary>
+        /// Tests that FaceUserConstraint updates the rotation to face the user
+        /// </summary>
+        [UnityTest]
+        public IEnumerator ConstrainRotationFaceUser()
+        {
+            TestUtilities.PlayspaceToOriginLookingForward();
+            
+            var testObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            testObject.transform.localScale = Vector3.one * 0.2f;
+            testObject.transform.position = Vector3.forward;
+            var manipHandler = testObject.AddComponent<ObjectManipulator>();
+            manipHandler.HostTransform = testObject.transform;
+            manipHandler.SmoothingActive = false;
+            manipHandler.ManipulationType = ManipulationHandFlags.OneHanded;
+            manipHandler.OneHandRotationModeNear = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+            var rotConstraint = manipHandler.EnsureComponent<FaceUserConstraint>();
+            rotConstraint.TargetTransform = manipHandler.HostTransform;
+            rotConstraint.FaceAway = false;
+
+            // Face user first
+            const int numHandSteps = 10;
+            TestHand hand = new TestHand(Handedness.Right);
+
+            yield return hand.Show(new Vector3(0.05f, -0.1f, 0.45f));
+            yield return hand.SetGesture(ArticulatedHandPose.GestureId.Pinch);
+            yield return null;
+
+            Vector3 cameraToObject() => testObject.transform.position - CameraCache.Main.transform.position;
+            Vector3 checkCollinear() => Vector3.Cross(testObject.transform.forward, cameraToObject());
+            float checkNegative() => Vector3.Dot(testObject.transform.forward, cameraToObject());
+
+            TestUtilities.AssertAboutEqual(checkCollinear(), Vector3.zero, "Object not facing camera", 0.002f);
+            Assert.Greater(checkNegative(), 0, "Object facing away");
+
+            // Move the hand
+            yield return hand.Move(new Vector3(0.2f, 0.2f, 0), numHandSteps);
+            yield return null;
+
+            Assert.AreNotEqual(Vector3.forward, testObject.transform.position); // ensure the object moved
+            TestUtilities.AssertAboutEqual(checkCollinear(), Vector3.zero, "Object not facing camera", 0.002f);
+            Assert.Greater(checkNegative(), 0, "Object facing away");
+
+            // Face away from user
+            rotConstraint.FaceAway = true;
+            yield return hand.Move(new Vector3(-0.2f, -0.2f, 0), numHandSteps);
+            yield return null;
+
+            TestUtilities.AssertAboutEqual(checkCollinear(), Vector3.zero, "Object not facing camera", 0.002f);
+            Assert.Less(checkNegative(), 0, "Object facing away");
+
+            // Move the hand
+            yield return hand.Move(new Vector3(0.2f, 0.2f, 0), numHandSteps);
+            yield return null;
+
+            Assert.AreNotEqual(Vector3.forward, testObject.transform.position); // ensure the object moved
+            TestUtilities.AssertAboutEqual(checkCollinear(), Vector3.zero, "Object not facing camera", 0.002f);
+            Assert.Less(checkNegative(), 0, "Object facing away");
+        }
     }
 }
 #endif

Assets/MixedRealityToolkit.Tests/PlayModeTests/ConstraintTests.cs

@@ -357,9 +357,7 @@ public IEnumerator ObjectManipulatorOneHandMoveFar()
             foreach (ObjectManipulator.RotateInOneHandType type in Enum.GetValues(typeof(ObjectManipulator.RotateInOneHandType)))
             {
                 // Some rotation modes move the object on grab, don't test those
-                if (type == ObjectManipulator.RotateInOneHandType.MaintainOriginalRotation ||
-                    type == ObjectManipulator.RotateInOneHandType.FaceAwayFromUser ||
-                    type == ObjectManipulator.RotateInOneHandType.FaceUser)
+                if (type == ObjectManipulator.RotateInOneHandType.MaintainOriginalRotation)
                 {
                     continue;
                 }