Fixes scale handle flattening alignment and resolves long-standing bug with FlattenAuto

Author: Zee2

Assets/MRTK/SDK/Features/UX/Scripts/BoundsControl/BoundsControl.cs

@@ -564,6 +564,21 @@ public ElasticsManager ElasticsManager
         private Vector3[] boundsCorners = new Vector3[8];
         public Vector3[] BoundsCorners { get; private set; }
 
+        // Current actual flattening axis, derived from FlattenAuto, if set
+        private FlattenModeType actualFlattenAxis {
+            get
+            {
+                if(FlattenAxis == FlattenModeType.FlattenAuto)
+                {
+                    return VisualUtils.DetermineAxisToFlatten(TargetBounds.bounds.extents);
+                }
+                else
+                {
+                    return FlattenAxis;
+                }
+            }
+        }
+
         #endregion
 
         #region public Properties
@@ -721,8 +736,8 @@ private static T EnsureScriptable<T>(T instance) where T : ScriptableObject
 
         private void OnEnable()
         {
-            SetActivationFlags();
             CreateRig();
+            SetActivationFlags();
             CaptureInitialState();
         }
 
@@ -1235,16 +1250,15 @@ private void TransformTarget(HandleType transformType)
                     // If non-uniform scaling or uniform scaling only on the non-flattened axes
                     if (ScaleHandlesConfig.ScaleBehavior != HandleScaleMode.Uniform || !UniformScaleOnFlattenedAxis)
                     {
-                        FlattenModeType determinedType = FlattenAxis == FlattenModeType.FlattenAuto ? VisualUtils.DetermineAxisToFlatten(TargetBounds.bounds.extents) : FlattenAxis;
-                        if (determinedType == FlattenModeType.FlattenX)
+                        if (actualFlattenAxis == FlattenModeType.FlattenX)
                         {
                             scaleFactor.x = 1;
                         }
-                        if (determinedType == FlattenModeType.FlattenY)
+                        if (actualFlattenAxis == FlattenModeType.FlattenY)
                         {
                             scaleFactor.y = 1;
                         }
-                        if (determinedType == FlattenModeType.FlattenZ)
+                        if (actualFlattenAxis == FlattenModeType.FlattenZ)
                         {
                             scaleFactor.z = 1;
                         }
@@ -1476,14 +1490,14 @@ private void ResetVisuals()
             }
 
             boxDisplay.Reset(active);
-            boxDisplay.UpdateFlattenAxis(flattenAxis);
+            boxDisplay.UpdateFlattenAxis(actualFlattenAxis);
 
             bool isVisible = (active == true && wireframeOnly == false);
 
-            rotationHandles.Reset(isVisible, flattenAxis);
-            links.Reset(active, flattenAxis);
-            scaleHandles.Reset(isVisible, flattenAxis);
-            translationHandles.Reset(isVisible, flattenAxis);
+            rotationHandles.Reset(isVisible, actualFlattenAxis);
+            links.Reset(active, actualFlattenAxis);
+            scaleHandles.Reset(isVisible, actualFlattenAxis);
+            translationHandles.Reset(isVisible, actualFlattenAxis);
         }
 
         private void CreateVisuals()
@@ -1543,7 +1557,7 @@ private void UpdateVisuals()
                 translationHandles.CalculateHandlePositions(ref boundsCorners);
                 scaleHandles.CalculateHandlePositions(ref boundsCorners);
 
-                boxDisplay.UpdateDisplay(currentBoundsExtents, flattenAxis);
+                boxDisplay.UpdateDisplay(currentBoundsExtents, actualFlattenAxis);
 
                 // move rig into position and rotation
                 rigRoot.position = TargetBounds.bounds.center;

Assets/MRTK/SDK/Features/UX/Scripts/BoundsControl/Visuals/ScaleHandles.cs

@@ -16,6 +16,7 @@ public class ScaleHandles : HandlesBase
         protected override HandlesBaseConfiguration BaseConfig => config;
         private ScaleHandlesConfiguration config;
         private bool areHandlesFlattened = false;
+        private FlattenModeType currentFlattenAxis = FlattenModeType.DoNotFlatten;
 
         /// <summary>
         /// Cached handle positions - we keep track of handle positions in this array
@@ -171,16 +172,9 @@ private Bounds CreateVisual(int handleIndex, GameObject parent, bool isFlattened
             handleVisual.transform.localPosition = Vector3.zero;
             handleVisual.transform.localRotation = Quaternion.identity;
 
-            if (isFlattened)
-            {
-                // Rotate 2D slate handle asset for proper orientation
-                parent.transform.Rotate(0, 0, -90);
-            }
-            else
-            {
-                Quaternion realignment = GetRotationRealignment(handleIndex);
-                parent.transform.localRotation = realignment;
-            }
+            
+            Quaternion realignment = GetRotationRealignment(handleIndex, isFlattened);
+            parent.transform.localRotation = realignment;
 
             if(config.HandleMaterial != null)
             {
@@ -190,7 +184,7 @@ private Bounds CreateVisual(int handleIndex, GameObject parent, bool isFlattened
             return handleVisualBounds;
         }
 
-        protected Quaternion GetRotationRealignment(int handleIndex)
+        protected Quaternion GetRotationRealignment(int handleIndex, bool isFlattened)
         {
             // Helper lambda to sign a vector.
             Vector3 signVector(Vector3 i) => new Vector3(Mathf.Sign(i.x), Mathf.Sign(i.y), Mathf.Sign(i.z));
@@ -200,21 +194,52 @@ protected Quaternion GetRotationRealignment(int handleIndex)
             Vector3 neutralHandle = signVector(HandlePositions[6]);
             Vector3 handlePos = signVector(HandlePositions[handleIndex]);
 
-            // Flip the handle if it's on the underside of the bounds.
-            Quaternion flip = Quaternion.Euler(0, 0, handlePos.y > 0 ? 0 : 90);
+            if(isFlattened)
+            {
+                Vector3 axis = Vector3.forward;
+                switch(currentFlattenAxis)
+                {
+                    case FlattenModeType.FlattenAuto:
+                        Debug.LogError("ScaleHandles should never receive FlattenAuto. BoundsControl should pass actualFlattenAxis");
+                        break;
+                    case FlattenModeType.FlattenX:
+                        axis = Vector3.right;
+                        break;
+                    case FlattenModeType.FlattenY:
+                        axis = -Vector3.up;
+                        break;
+                    case FlattenModeType.FlattenZ:
+                        axis = Vector3.forward;
+                        break;
+                }
+
+                Vector3 neutralProjected = Vector3.ProjectOnPlane(neutralHandle, axis);
+                Vector3 handleProjected = Vector3.ProjectOnPlane(handlePos, axis);
 
-            float angleAroundVertical = Vector3.SignedAngle(new Vector3(neutralHandle.x, 0, neutralHandle.z),
-                                                            new Vector3(handlePos.x, 0, handlePos.z),
-                                                            Vector3.up);
+                float angleAroundAxis = Vector3.SignedAngle(neutralProjected,
+                                                                handleProjected,
+                                                                axis);
 
-            return Quaternion.Euler(0, angleAroundVertical, 0) * flip;
+                return Quaternion.AngleAxis(angleAroundAxis, axis) * Quaternion.LookRotation(axis, Vector3.up);
+            }
+            else
+            {
+                // Flip the handle if it's on the underside of the bounds.
+                Quaternion flip = Quaternion.Euler(0, 0, handlePos.y > 0 ? 0 : 90);
+
+                float angleAroundVertical = Vector3.SignedAngle(new Vector3(neutralHandle.x, 0, neutralHandle.z),
+                                                                new Vector3(handlePos.x, 0, handlePos.z),
+                                                                Vector3.up);
+                return Quaternion.Euler(0, angleAroundVertical, 0) * flip;
+            }   
         }
 
         internal void Reset(bool areHandlesActive, FlattenModeType flattenAxis)
         {
             IsActive = areHandlesActive;
             ResetHandles();
             bool isFlattened = flattenAxis != FlattenModeType.DoNotFlatten;
+            currentFlattenAxis = flattenAxis;
             if (areHandlesFlattened != isFlattened)
             {
                 areHandlesFlattened = isFlattened;