Move MaintainOriginalRotation to a TransformConstraint

Also updated and implemented new tests.

Author: MenelvagorMilsom

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

@@ -25,7 +25,6 @@ public class ObjectManipulator : MonoBehaviour, IMixedRealityPointerHandler, IMi
         #region Public Enums
         public enum RotateInOneHandType
         {
-            MaintainOriginalRotation,
             RotateAboutObjectCenter,
             RotateAboutGrabPoint
         };
@@ -589,23 +588,16 @@ private void HandleOneHandMoveUpdated()
 
             constraints.ApplyScaleConstraints(ref targetTransform, true, IsNearManipulation());
 
-            RotateInOneHandType rotateInOneHandType = isNearManipulation ? oneHandRotationModeNear : oneHandRotationModeFar;
-            switch (rotateInOneHandType)
-            {
-                case RotateInOneHandType.MaintainOriginalRotation:
-                    targetTransform.Rotation = HostTransform.rotation;
-                    break;
-                case RotateInOneHandType.RotateAboutObjectCenter:
-                case RotateInOneHandType.RotateAboutGrabPoint:
-                    Quaternion gripRotation;
-                    TryGetGripRotation(pointer, out gripRotation);
-                    targetTransform.Rotation = gripRotation * objectToGripRotation;
-                    break;
-            }
+            Quaternion gripRotation;
+            TryGetGripRotation(pointer, out gripRotation);
+            targetTransform.Rotation = gripRotation * objectToGripRotation;
+
             constraints.ApplyRotationConstraints(ref targetTransform, true, IsNearManipulation());
 
+            RotateInOneHandType rotateInOneHandType = isNearManipulation ? oneHandRotationModeNear : oneHandRotationModeFar;
             MixedRealityPose pointerPose = new MixedRealityPose(pointer.Position, pointer.Rotation);
             targetTransform.Position = moveLogic.Update(pointerPose, targetTransform.Rotation, targetTransform.Scale, rotateInOneHandType != RotateInOneHandType.RotateAboutObjectCenter);
+
             constraints.ApplyTranslationConstraints(ref targetTransform, true, IsNearManipulation());
 
             ApplyTargetTransform(targetTransform);
@@ -779,7 +771,6 @@ private PointerData GetFirstPointer()
 
         private bool TryGetGripRotation(IMixedRealityPointer pointer, out Quaternion rotation)
         {
-
             for (int i = 0; i < pointer.Controller.Interactions.Length; i++)
             {
                 if (pointer.Controller.Interactions[i].InputType == DeviceInputType.SpatialGrip)

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

@@ -164,8 +164,15 @@ private void MigrateOneHandRotationModes(ref ObjectManipulator objManip, Manipul
                         break;
                     }
                 case ManipulationHandler.RotateInOneHandType.MaintainOriginalRotation:
-                    newMode = ObjectManipulator.RotateInOneHandType.MaintainOriginalRotation;
-                    break;
+                    {
+                        newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+                        var rotConstraint = objManip.EnsureComponent<FixedRotationToWorldConstraint>();
+                        rotConstraint.TargetTransform = objManip.HostTransform;
+                        rotConstraint.HandType = ManipulationHandFlags.OneHanded;
+                        rotConstraint.ProximityType = proximity;
+                        break;
+                    }
                 case ManipulationHandler.RotateInOneHandType.RotateAboutObjectCenter:
                     newMode = ObjectManipulator.RotateInOneHandType.RotateAboutObjectCenter;
                     break;

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

@@ -0,0 +1,32 @@
+// 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 relative to the world
+    /// </summary>
+    public class FixedRotationToWorldConstraint : TransformConstraint
+    {
+        #region Properties
+
+        public override TransformFlags ConstraintType => TransformFlags.Rotate;
+
+        #endregion Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Fix rotation to the rotation from manipulation start
+        /// </summary>
+        public override void ApplyConstraint(ref MixedRealityTransform transform)
+        {
+            transform.Rotation = this.worldPoseOnManipulationStart.Rotation;
+        }
+
+        #endregion Public Methods
+    }
+}

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

@@ -813,6 +813,54 @@ public IEnumerator ConstrainRotationFaceUser()
             TestUtilities.AssertAboutEqual(checkCollinear(), Vector3.zero, "Object not facing camera", 0.002f);
             Assert.Less(checkNegative(), 0, "Object facing away");
         }
+
+        /// <summary>
+        /// Tests that FixedRotationToWorldConstraint maintains the original rotation of the manipulated object
+        /// </summary>
+        [UnityTest]
+        public IEnumerator ConstrainRotationFixToWorld()
+        {
+            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<FixedRotationToWorldConstraint>();
+            rotConstraint.TargetTransform = manipHandler.HostTransform;
+
+            // Face user first
+            const int numHandSteps = 1;
+            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;
+
+            // rotate the hand
+            yield return hand.SetRotation(Quaternion.Euler(45, 45, 45), numHandSteps);
+            yield return null;
+
+            Assert.AreEqual(Quaternion.identity, testObject.transform.rotation);
+
+            // move the hand
+            yield return hand.Move(Vector3.right * 0.2f, numHandSteps);
+            yield return null;
+
+            Assert.AreEqual(Quaternion.identity, testObject.transform.rotation);
+
+            // rotate the head
+            CameraCache.Main.transform.Rotate(new Vector3(0, 10, 0));
+            yield return new WaitForFixedUpdate();
+            yield return null;
+
+            Assert.AreEqual(Quaternion.identity, testObject.transform.rotation);
+        }
     }
 }
 #endif

Assets/MixedRealityToolkit.Tests/PlayModeTests/ConstraintTests.cs

@@ -356,12 +356,6 @@ public IEnumerator ObjectManipulatorOneHandMoveFar()
             // do this test for every one hand rotation mode
             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)
-                {
-                    continue;
-                }         
-
                 manipHandler.OneHandRotationModeFar = type;
 
                 TestUtilities.PlayspaceToOriginLookingForward();