Merge pull request #7377 from Troy-Ferrell/users/trferrel/rotation-theme-fix

Fix visual rotation theme for toggling local vs world space rotation

Author: Troy-Ferrell

Assets/MixedRealityToolkit.SDK/Features/UX/Interactable/Themes/Model_BuckyTheme.asset

@@ -145,6 +145,27 @@ MonoBehaviour:
         Quaternion: {x: 0, y: 0, z: 0, w: 0}
         AudioClip: {fileID: 0}
         Animation: {fileID: 0}
+    - Name: Local Rotation
+      Tooltip: Should the theme manipulate the target's local rotation or world space
+        rotation
+      Type: 15
+      Value:
+        Name: 
+        String: 
+        Bool: 0
+        Int: 0
+        Float: 0
+        Texture: {fileID: 0}
+        Material: {fileID: 0}
+        Shader: {fileID: 0}
+        GameObject: {fileID: 0}
+        Vector2: {x: 0, y: 0}
+        Vector3: {x: 0, y: 0, z: 0}
+        Vector4: {x: 0, y: 0, z: 0, w: 0}
+        Color: {r: 0, g: 0, b: 0, a: 0}
+        Quaternion: {x: 0, y: 0, z: 0, w: 0}
+        AudioClip: {fileID: 0}
+        Animation: {fileID: 0}
     easing:
       Enabled: 1
       Curve:

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/VisualThemes/ThemeEngines/InteractableRotationTheme.cs

@@ -12,9 +12,22 @@ namespace Microsoft.MixedReality.Toolkit.UI
     /// </summary>
     public class InteractableRotationTheme : InteractableThemeBase
     {
+        /// <summary>
+        /// If true, the theme rotation value will be added to the initial Gameobject's rotation. Otherwise, it will set directly as absolute euler angles.
+        /// </summary>
+        public bool IsRelativeRotation => GetThemeProperty(RelativeRotationPropertyIndex).Value.Bool;
+
+        /// <summary>
+        /// If true, the theme manipulate the target's local rotation. Otherwise, the theme will control the world space rotation.
+        /// </summary>
+        public bool IsLocalRotation => GetThemeProperty(LocalRotationPropertyIndex).Value.Bool;
+
         protected Vector3 originalRotation;
         protected Transform hostTransform;
 
+        private const int RelativeRotationPropertyIndex = 0;
+        private const int LocalRotationPropertyIndex = 1;
+
         public InteractableRotationTheme()
         {
             Types = new Type[] { typeof(Transform) };
@@ -42,10 +55,17 @@ public override ThemeDefinition GetDefaultThemeDefinition()
                     new ThemeProperty()
                     {
                         Name = "Relative Rotation",
-                        Tooltip = "Should the rotation be added to initial Gameobject rotation, or absolute",
+                        Tooltip = "Should the theme rotation value be added to the initial Gameobject's rotation, or set directly as absolute euler angles",
                         Type = ThemePropertyTypes.Bool,
                         Value = new ThemePropertyValue() { Bool = false }
                     },
+                    new ThemeProperty()
+                    {
+                        Name = "Local Rotation",
+                        Tooltip = "Should the theme manipulate the target's local rotation or world space rotation",
+                        Type = ThemePropertyTypes.Bool,
+                        Value = new ThemePropertyValue() { Bool = true }
+                    },
                 },
             };
         }
@@ -56,14 +76,14 @@ public override void Init(GameObject host, ThemeDefinition settings)
             base.Init(host, settings);
 
             hostTransform = Host.transform;
-            originalRotation = hostTransform.localEulerAngles;
+            originalRotation = IsLocalRotation ? hostTransform.localEulerAngles : hostTransform.eulerAngles;
         }
 
         /// <inheritdoc />
         public override ThemePropertyValue GetProperty(ThemeStateProperty property)
         {
             ThemePropertyValue start = new ThemePropertyValue();
-            start.Vector3 = hostTransform.eulerAngles;
+            start.Vector3 = IsLocalRotation ? hostTransform.localEulerAngles : hostTransform.eulerAngles;
             return start;
         }
 
@@ -72,13 +92,21 @@ public override void SetValue(ThemeStateProperty property, int index, float perc
         {
             Vector3 lerpTarget = property.Values[index].Vector3;
 
-            bool relative = Properties[0].Value.Bool;
-            if (relative)
+            if (IsRelativeRotation)
             {
                 lerpTarget = originalRotation + lerpTarget;
             }
 
-            hostTransform.localRotation = Quaternion.Euler(Vector3.Lerp(property.StartValue.Vector3, lerpTarget, percentage));
+            var setValue = Quaternion.Euler(Vector3.Lerp(property.StartValue.Vector3, lerpTarget, percentage));
+
+            if (IsLocalRotation)
+            {
+                hostTransform.localRotation = setValue;
+            }
+            else
+            {
+                hostTransform.rotation = setValue;
+            }
         }
     }
 }

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/VisualThemes/ThemeEngines/InteractableThemeBase.cs

@@ -222,5 +222,22 @@ protected int LerpInt(int s, int e, float t)
         {
             return Mathf.RoundToInt((e - s) * t) + s;
         }
+
+        protected ThemeProperty GetThemeProperty(int index)
+        {
+            if (index >= 0)
+            {
+                if (Properties != null && Properties.Count > index)
+                {
+                    return Properties[index];
+                }
+
+                // If Theme's data does not have desired property, return defaults.
+                // If index is not in range, throw exception to fail fast. 
+                return GetDefaultThemeDefinition().CustomProperties[index];
+            }
+
+            return null;
+        }
     }
 }

Assets/MixedRealityToolkit.Tests/PlayModeTests/VisualThemeTests.cs

@@ -105,9 +105,16 @@ public IEnumerator TestOffsetTheme()
                 (theme) => { Assert.AreEqual(state1, theme.Host.transform.position); });
         }
 
+        /// <summary>
+        /// Test InteractableRotationTheme applied not as local, non-relative rotation to host target
+        /// </summary>
         [UnityTest]
         public IEnumerator TestRotationTheme()
         {
+            // Point Cube diagonally to right
+            var hostGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            hostGameObject.transform.rotation = Quaternion.LookRotation(Vector3.forward + Vector3.right);
+
             Vector3 state0 = Quaternion.LookRotation(Vector3.up).eulerAngles;
             Vector3 state1 = Quaternion.LookRotation(Vector3.down).eulerAngles;
 
@@ -120,9 +127,44 @@ public IEnumerator TestRotationTheme()
                 }
             };
 
-            yield return TestTheme<InteractableRotationTheme, MeshRenderer>(defaultStateValues,
-                (theme) => { Assert.AreEqual(state0, theme.Host.transform.rotation.eulerAngles); },
-                (theme) => { Assert.AreEqual(state1, theme.Host.transform.rotation.eulerAngles); });
+            yield return TestTheme<InteractableRotationTheme, MeshRenderer>(hostGameObject, defaultStateValues,
+                (theme) => { Assert.AreEqual(state0, theme.Host.transform.localEulerAngles); },
+                (theme) => { Assert.AreEqual(state1, theme.Host.transform.localEulerAngles); });
+        }
+
+        /// <summary>
+        /// Test InteractableRotationTheme applied not as world space, relative rotation to host target
+        /// </summary>
+        [UnityTest]
+        public IEnumerator TestRotationThemeWorldSpace()
+        {
+            // Point Cube diagonally to right
+            var hostGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            var initRotation = Quaternion.LookRotation(Vector3.forward + Vector3.right); ;
+            hostGameObject.transform.rotation = initRotation;
+
+            Vector3 state0 = Quaternion.LookRotation(Vector3.up).eulerAngles;
+            Vector3 state1 = Quaternion.LookRotation(Vector3.down).eulerAngles;
+
+            var defaultStateValues = new List<List<ThemePropertyValue>>()
+            {
+                new List<ThemePropertyValue>()
+                {
+                    new ThemePropertyValue() { Vector3 = state0 },
+                    new ThemePropertyValue() { Vector3 = state1 },
+                }
+            };
+
+            // Generate default theme properties for InteractableRotationTheme. 
+            // Set Relative Rotation property (index=0) to true so theme values are applied in addition instead of absolutely set
+            // Set Local Rotation property (index=1) to false so euler angles are world space
+            var defaultThemeProperties = (new InteractableRotationTheme()).GetDefaultThemeDefinition().CustomProperties;
+            defaultThemeProperties[0].Value.Bool = true;
+            defaultThemeProperties[1].Value.Bool = false;
+
+            yield return TestTheme<InteractableRotationTheme, MeshRenderer>(hostGameObject, defaultStateValues, defaultThemeProperties,
+                (theme) => { Assert.AreEqual(initRotation.eulerAngles + state0, theme.Host.transform.eulerAngles); },
+                (theme) => { Assert.AreEqual(initRotation.eulerAngles + state1, theme.Host.transform.eulerAngles); });
         }
 
         /// <summary>