Remove MaintainRotationToUser

Also removed GravityAlignedMaintainRotationToUser as this can be achieved with an additional RotationAxisConstraint. Also added options to configure what manipulation type a constraint should work for.

Author: MenelvagorMilsom

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

@@ -23,16 +23,8 @@ namespace Microsoft.MixedReality.Toolkit.Experimental.UI
     public class ObjectManipulator : MonoBehaviour, IMixedRealityPointerHandler, IMixedRealityFocusChangedHandler
     {
         #region Public Enums
-        [System.Flags]
-        public enum HandMovementType
-        {
-            OneHanded = 1 << 0,
-            TwoHanded = 1 << 1,
-        }
         public enum RotateInOneHandType
         {
-            MaintainRotationToUser,
-            GravityAlignedMaintainRotationToUser,
             FaceUser,
             FaceAwayFromUser,
             MaintainOriginalRotation,
@@ -73,12 +65,12 @@ public Transform HostTransform
         [SerializeField]
         [EnumFlags]
         [Tooltip("Can manipulation be done only with one hand, only with two hands, or with both?")]
-        private HandMovementType manipulationType = HandMovementType.OneHanded | HandMovementType.TwoHanded;
+        private ManipulationHandFlags manipulationType = ManipulationHandFlags.OneHanded | ManipulationHandFlags.TwoHanded;
 
         /// <summary>
         /// Can manipulation be done only with one hand, only with two hands, or with both?
         /// </summary>
-        public HandMovementType ManipulationType
+        public ManipulationHandFlags ManipulationType
         {
             get => manipulationType;
             set => manipulationType = value;
@@ -298,15 +290,13 @@ public PointerData(IMixedRealityPointer pointer, Vector3 worldGrabPoint) : this(
 
         private Rigidbody rigidBody;
         private bool wasKinematic = false;
-
-        private Quaternion startObjectRotationCameraSpace;
-        private Quaternion startObjectRotationFlatCameraSpace;
+        
         private Quaternion hostWorldRotationOnManipulationStart;
 
         private ConstraintManager constraints;
 
-        private bool IsOneHandedManipulationEnabled => manipulationType.HasFlag(HandMovementType.OneHanded) && pointerIdToPointerMap.Count == 1;
-        private bool IsTwoHandedManipulationEnabled => manipulationType.HasFlag(HandMovementType.TwoHanded) && pointerIdToPointerMap.Count > 1;
+        private bool IsOneHandedManipulationEnabled => manipulationType.HasFlag(ManipulationHandFlags.OneHanded) && pointerIdToPointerMap.Count == 1;
+        private bool IsTwoHandedManipulationEnabled => manipulationType.HasFlag(ManipulationHandFlags.TwoHanded) && pointerIdToPointerMap.Count > 1;
 
         #endregion
 
@@ -442,7 +432,7 @@ public void OnPointerDown(MixedRealityPointerEventData eventData)
             }
 
             // If we only allow one handed manipulations, check there is no hand interacting yet. 
-            if (manipulationType != HandMovementType.OneHanded || pointerIdToPointerMap.Count == 0)
+            if (manipulationType != ManipulationHandFlags.OneHanded || pointerIdToPointerMap.Count == 0)
             {
                 uint id = eventData.Pointer.PointerId;
                 // Ignore poke pointer events
@@ -509,9 +499,9 @@ public void OnPointerUp(MixedRealityPointerEventData eventData)
 
             // Call manipulation ended handlers
             var handsPressedCount = pointerIdToPointerMap.Count;
-            if (manipulationType.HasFlag(HandMovementType.TwoHanded) && handsPressedCount == 1)
+            if (manipulationType.HasFlag(ManipulationHandFlags.TwoHanded) && handsPressedCount == 1)
             {
-                if (manipulationType.HasFlag(HandMovementType.OneHanded))
+                if (manipulationType.HasFlag(ManipulationHandFlags.OneHanded))
                 {
                     HandleOneHandMoveStarted();
                 }
@@ -560,18 +550,18 @@ private void HandleTwoHandManipulationUpdated()
             if (twoHandedManipulationType.HasFlag(TransformFlags.Scale))
             {
                 targetTransform.Scale = scaleLogic.UpdateMap(handPositionArray);
-                constraints.ApplyScaleConstraints(ref targetTransform);
+                constraints.ApplyScaleConstraints(ref targetTransform, false, IsNearManipulation());
             }
             if (twoHandedManipulationType.HasFlag(TransformFlags.Rotate))
             {
                 targetTransform.Rotation = rotateLogic.Update(handPositionArray, targetTransform.Rotation);
-                constraints.ApplyRotationConstraints(ref targetTransform);
+                constraints.ApplyRotationConstraints(ref targetTransform, false, IsNearManipulation());
             }
             if (twoHandedManipulationType.HasFlag(TransformFlags.Move))
             {
                 MixedRealityPose pose = GetPointersPose();
                 targetTransform.Position = moveLogic.Update(pose, targetTransform.Rotation, targetTransform.Scale, true);
-                constraints.ApplyTranslationConstraints(ref targetTransform);
+                constraints.ApplyTranslationConstraints(ref targetTransform, false, IsNearManipulation());
             }
 
             ApplyTargetTransform(targetTransform);
@@ -600,15 +590,7 @@ private void HandleOneHandMoveStarted()
 
             MixedRealityPose pointerPose = new MixedRealityPose(pointer.Position, pointer.Rotation);
             MixedRealityPose hostPose = new MixedRealityPose(HostTransform.position, HostTransform.rotation);
-            moveLogic.Setup(pointerPose, pointerData.GrabPoint, hostPose, HostTransform.localScale);
-
-            startObjectRotationCameraSpace = Quaternion.Inverse(CameraCache.Main.transform.rotation) * HostTransform.rotation;
-            var cameraFlat = CameraCache.Main.transform.forward;
-            cameraFlat.y = 0;
-            var hostForwardFlat = HostTransform.forward;
-            hostForwardFlat.y = 0;
-            var hostRotFlat = Quaternion.LookRotation(hostForwardFlat, Vector3.up);
-            startObjectRotationFlatCameraSpace = Quaternion.Inverse(Quaternion.LookRotation(cameraFlat, Vector3.up)) * hostRotFlat;
+            moveLogic.Setup(pointerPose, pointerData.GrabPoint, hostPose, HostTransform.localScale);            
         }
 
         private void HandleOneHandMoveUpdated()
@@ -619,24 +601,14 @@ private void HandleOneHandMoveUpdated()
 
             var targetTransform = new MixedRealityTransform(HostTransform.position, HostTransform.rotation, HostTransform.localScale);
 
-            constraints.ApplyScaleConstraints(ref targetTransform);
+            constraints.ApplyScaleConstraints(ref targetTransform, true, IsNearManipulation());
 
             RotateInOneHandType rotateInOneHandType = isNearManipulation ? oneHandRotationModeNear : oneHandRotationModeFar;
             switch (rotateInOneHandType)
             {
                 case RotateInOneHandType.MaintainOriginalRotation:
                     targetTransform.Rotation = HostTransform.rotation;
                     break;
-                case RotateInOneHandType.MaintainRotationToUser:
-                    Vector3 euler = CameraCache.Main.transform.rotation.eulerAngles;
-                    // don't use roll (feels awkward) - just maintain yaw / pitch angle
-                    targetTransform.Rotation = Quaternion.Euler(euler.x, euler.y, 0) * startObjectRotationCameraSpace;
-                    break;
-                case RotateInOneHandType.GravityAlignedMaintainRotationToUser:
-                    var cameraForwardFlat = CameraCache.Main.transform.forward;
-                    cameraForwardFlat.y = 0;
-                    targetTransform.Rotation = Quaternion.LookRotation(cameraForwardFlat, Vector3.up) * startObjectRotationFlatCameraSpace;
-                    break;
                 case RotateInOneHandType.FaceUser:
                 {
                     Vector3 directionToTarget = pointerData.GrabPoint - CameraCache.Main.transform.position;
@@ -657,11 +629,11 @@ private void HandleOneHandMoveUpdated()
                     targetTransform.Rotation = gripRotation * objectToGripRotation;
                     break;
             }
-            constraints.ApplyRotationConstraints(ref targetTransform);
+            constraints.ApplyRotationConstraints(ref targetTransform, true, IsNearManipulation());
 
             MixedRealityPose pointerPose = new MixedRealityPose(pointer.Position, pointer.Rotation);
             targetTransform.Position = moveLogic.Update(pointerPose, targetTransform.Rotation, targetTransform.Scale, rotateInOneHandType != RotateInOneHandType.RotateAboutObjectCenter);
-            constraints.ApplyTranslationConstraints(ref targetTransform);
+            constraints.ApplyTranslationConstraints(ref targetTransform, true, IsNearManipulation());
 
             ApplyTargetTransform(targetTransform);
         }

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

@@ -23,82 +23,149 @@ public bool CanMigrate(GameObject gameObject)
         /// <inheritdoc />
         public void Migrate(GameObject gameObject)
         {
-            var mh1 = gameObject.GetComponent<ManipulationHandler>();
-            var mh2 = gameObject.AddComponent<ObjectManipulator>();
+            var manipHandler = gameObject.GetComponent<ManipulationHandler>();
+            var objManip = gameObject.AddComponent<ObjectManipulator>();
 
-            mh2.HostTransform = mh1.HostTransform;
+            objManip.HostTransform = manipHandler.HostTransform;
 
-            switch (mh1.ManipulationType)
+            switch (manipHandler.ManipulationType)
             {
                 case ManipulationHandler.HandMovementType.OneHandedOnly:
-                    mh2.ManipulationType = ObjectManipulator.HandMovementType.OneHanded;
+                    objManip.ManipulationType = ManipulationHandFlags.OneHanded;
                     break;
                 case ManipulationHandler.HandMovementType.TwoHandedOnly:
-                    mh2.ManipulationType = ObjectManipulator.HandMovementType.TwoHanded;
+                    objManip.ManipulationType = ManipulationHandFlags.TwoHanded;
                     break;
                 case ManipulationHandler.HandMovementType.OneAndTwoHanded:
-                    mh2.ManipulationType = ObjectManipulator.HandMovementType.OneHanded |
-                        ObjectManipulator.HandMovementType.TwoHanded;
+                    objManip.ManipulationType = ManipulationHandFlags.OneHanded |
+                        ManipulationHandFlags.TwoHanded;
                     break;
             }
 
-            mh2.AllowFarManipulation = mh1.AllowFarManipulation;
-            mh2.OneHandRotationModeNear = (ObjectManipulator.RotateInOneHandType)mh1.OneHandRotationModeNear;
-            mh2.OneHandRotationModeFar = (ObjectManipulator.RotateInOneHandType)mh1.OneHandRotationModeFar;
+            objManip.AllowFarManipulation = manipHandler.AllowFarManipulation;
 
-            switch (mh1.TwoHandedManipulationType)
+            if (manipHandler.OneHandRotationModeNear == manipHandler.OneHandRotationModeFar)
+            {
+                MigrateOneHandRotationModes(ref objManip, manipHandler.OneHandRotationModeNear, ManipulationProximityFlags.Near | ManipulationProximityFlags.Far);
+            }
+            else
+            {
+                MigrateOneHandRotationModes(ref objManip, manipHandler.OneHandRotationModeNear, ManipulationProximityFlags.Near);
+                MigrateOneHandRotationModes(ref objManip, manipHandler.OneHandRotationModeFar, ManipulationProximityFlags.Far);
+            }
+
+            switch (manipHandler.TwoHandedManipulationType)
             {
                 case ManipulationHandler.TwoHandedManipulation.Scale:
-                    mh2.TwoHandedManipulationType = TransformFlags.Scale;
+                    objManip.TwoHandedManipulationType = TransformFlags.Scale;
                     break;
                 case ManipulationHandler.TwoHandedManipulation.Rotate:
-                    mh2.TwoHandedManipulationType = TransformFlags.Rotate;
+                    objManip.TwoHandedManipulationType = TransformFlags.Rotate;
                     break;
                 case ManipulationHandler.TwoHandedManipulation.MoveScale:
-                    mh2.TwoHandedManipulationType = TransformFlags.Move |
+                    objManip.TwoHandedManipulationType = TransformFlags.Move |
                         TransformFlags.Scale;
                     break;
                 case ManipulationHandler.TwoHandedManipulation.MoveRotate:
-                    mh2.TwoHandedManipulationType = TransformFlags.Move |
+                    objManip.TwoHandedManipulationType = TransformFlags.Move |
                         TransformFlags.Rotate;
                     break;
                 case ManipulationHandler.TwoHandedManipulation.RotateScale:
-                    mh2.TwoHandedManipulationType = TransformFlags.Rotate |
+                    objManip.TwoHandedManipulationType = TransformFlags.Rotate |
                         TransformFlags.Scale;
                     break;
                 case ManipulationHandler.TwoHandedManipulation.MoveRotateScale:
-                    mh2.TwoHandedManipulationType = TransformFlags.Move |
+                    objManip.TwoHandedManipulationType = TransformFlags.Move |
                         TransformFlags.Rotate |
                         TransformFlags.Scale;
                     break;
             }
 
-            mh2.ReleaseBehavior = (ObjectManipulator.ReleaseBehaviorType)mh1.ReleaseBehavior;
+            objManip.ReleaseBehavior = (ObjectManipulator.ReleaseBehaviorType)manipHandler.ReleaseBehavior;
 
-            if (mh1.ConstraintOnRotation != RotationConstraintType.None)
+            if (manipHandler.ConstraintOnRotation != RotationConstraintType.None)
             {
-                var rotateConstraint = mh2.gameObject.AddComponent<RotationAxisConstraint>();
-                rotateConstraint.TargetTransform = mh1.HostTransform;
-                rotateConstraint.ConstraintOnRotation = RotationConstraintHelper.ConvertToAxisFlags(mh1.ConstraintOnRotation);
+                var rotateConstraint = objManip.EnsureComponent<RotationAxisConstraint>();
+                rotateConstraint.TargetTransform = manipHandler.HostTransform;
+                rotateConstraint.ConstraintOnRotation = RotationConstraintHelper.ConvertToAxisFlags(manipHandler.ConstraintOnRotation);
             }
 
-            if (mh1.ConstraintOnMovement == MovementConstraintType.FixDistanceFromHead)
+            if (manipHandler.ConstraintOnMovement == MovementConstraintType.FixDistanceFromHead)
             {
-                var moveConstraint = mh2.gameObject.AddComponent<FixedDistanceConstraint>();
-                moveConstraint.TargetTransform = mh1.HostTransform;
+                var moveConstraint = objManip.EnsureComponent<FixedDistanceConstraint>();
+                moveConstraint.TargetTransform = manipHandler.HostTransform;
                 moveConstraint.ConstraintTransform = CameraCache.Main.transform;
             }
 
-            mh2.SmoothingActive = mh1.SmoothingActive;
-            mh2.MoveLerpTime = mh1.SmoothingAmoutOneHandManip;
-            mh2.RotateLerpTime = mh1.SmoothingAmoutOneHandManip;
-            mh2.ScaleLerpTime = mh1.SmoothingAmoutOneHandManip;
-            mh2.OnManipulationStarted = mh1.OnManipulationStarted;
-            mh2.OnManipulationEnded = mh1.OnManipulationEnded;
-            mh2.OnHoverEntered = mh1.OnHoverEntered;
-            mh2.OnHoverExited = mh1.OnHoverExited;
+            objManip.SmoothingActive = manipHandler.SmoothingActive;
+            objManip.MoveLerpTime = manipHandler.SmoothingAmoutOneHandManip;
+            objManip.RotateLerpTime = manipHandler.SmoothingAmoutOneHandManip;
+            objManip.ScaleLerpTime = manipHandler.SmoothingAmoutOneHandManip;
+            objManip.OnManipulationStarted = manipHandler.OnManipulationStarted;
+            objManip.OnManipulationEnded = manipHandler.OnManipulationEnded;
+            objManip.OnHoverEntered = manipHandler.OnHoverEntered;
+            objManip.OnHoverExited = manipHandler.OnHoverExited;
+
+            Object.DestroyImmediate(manipHandler);
+        }
+
+        private void MigrateOneHandRotationModes(ref ObjectManipulator objManip, ManipulationHandler.RotateInOneHandType mode, ManipulationProximityFlags proximity)
+        {
+            ObjectManipulator.RotateInOneHandType newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+            switch (mode)
+            {
+                case ManipulationHandler.RotateInOneHandType.MaintainRotationToUser:
+                    {
+                        newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+
+                        var constraint = objManip.EnsureComponent<FixedRotationToUserConstraint>();
+                        constraint.TargetTransform = objManip.HostTransform;
+                        constraint.HandType = ManipulationHandFlags.OneHanded;
+                        constraint.ProximityType = proximity;
+                        break;
+                    }
+                case ManipulationHandler.RotateInOneHandType.GravityAlignedMaintainRotationToUser:
+                    {
+                        newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
 
-            Object.DestroyImmediate(mh1);
+                        var rotConstraint = objManip.EnsureComponent<FixedRotationToUserConstraint>();
+                        rotConstraint.TargetTransform = objManip.HostTransform;
+                        rotConstraint.HandType = ManipulationHandFlags.OneHanded;
+                        rotConstraint.ProximityType = proximity;
+
+                        var axisConstraint = objManip.EnsureComponent<RotationAxisConstraint>();
+                        axisConstraint.TargetTransform = objManip.HostTransform;
+                        axisConstraint.HandType = ManipulationHandFlags.OneHanded;
+                        axisConstraint.ProximityType = proximity;
+                        axisConstraint.ConstraintOnRotation = AxisFlags.XAxis | AxisFlags.ZAxis;
+                        break;
+                    }
+                case ManipulationHandler.RotateInOneHandType.FaceUser:
+                    newMode = ObjectManipulator.RotateInOneHandType.FaceUser;
+                    break;
+                case ManipulationHandler.RotateInOneHandType.FaceAwayFromUser:
+                    newMode = ObjectManipulator.RotateInOneHandType.FaceAwayFromUser;
+                    break;
+                case ManipulationHandler.RotateInOneHandType.MaintainOriginalRotation:
+                    newMode = ObjectManipulator.RotateInOneHandType.MaintainOriginalRotation;
+                    break;
+                case ManipulationHandler.RotateInOneHandType.RotateAboutObjectCenter:
+                    newMode = ObjectManipulator.RotateInOneHandType.RotateAboutObjectCenter;
+                    break;
+                case ManipulationHandler.RotateInOneHandType.RotateAboutGrabPoint:
+                    newMode = ObjectManipulator.RotateInOneHandType.RotateAboutGrabPoint;
+                    break;
+            }
+
+            if (proximity.HasFlag(ManipulationProximityFlags.Near))
+            {
+                objManip.OneHandRotationModeNear = newMode;
+            }
+            if (proximity.HasFlag(ManipulationProximityFlags.Far))
+            {
+                objManip.OneHandRotationModeFar = newMode;
+            }
         }
     }
 }