Merge pull request #6858 from artsouflMS/PinchSliderOrientation

Pinch slider orientation

Author: keveleigh

Assets/MixedRealityToolkit.SDK/Features/UX/Prefabs/Sliders/PinchSlider.prefab

@@ -1061,6 +1061,7 @@ MonoBehaviour:
   columns: 13
   cellWidth: 0.021
   cellHeight: 0.01
+  assetVersion: 1
 --- !u!1 &7307063430618434862
 GameObject:
   m_ObjectHideFlags: 0
@@ -1110,6 +1111,9 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   thumbRoot: {fileID: 7307063430758334042}
   sliderValue: 0.5
+  trackVisuals: {fileID: 7307063431327029218}
+  tickMarks: {fileID: 7307063430561165487}
+  thumbVisual: {fileID: 7307063430134822100}
   sliderAxis: 0
   sliderStartDistance: -0.125
   sliderEndDistance: 0.125

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/Sliders/PinchSlider.cs

@@ -48,17 +48,86 @@ public float SliderValue
             }
         }
 
+        [Header("Slider Axis Visuals")]
+    
+        [Tooltip("The gameObject that contains the trackVisuals. This will get rotated to match the slider axis")]
+        [SerializeField]
+        private GameObject trackVisuals = null;
+        /// <summary>
+        /// Property accessor of trackVisuals, it contains the desired track Visuals. This will get rotated to match the slider axis.
+        /// </summary>
+        public GameObject TrackVisuals
+        {
+            get
+            {
+                return trackVisuals;
+            }
+            set
+            {
+                trackVisuals = value;
+                UpdateTrackVisuals();
+            }
+        }
+
+        [Tooltip("The gameObject that contains the tickMarks.  This will get rotated to match the slider axis")]
+        [SerializeField]
+        private GameObject tickMarks = null;
+        /// <summary>
+        /// Property accessor of tickMarks, it contains the desired tick Marks.  This will get rotated to match the slider axis.
+        /// </summary>
+        public GameObject TickMarks
+        {
+            get
+            {
+                return tickMarks;
+            }
+            set
+            {
+                tickMarks = value;
+                UpdateTickMarks();
+            }
+        }
+
+
         [Header("Slider Track")]
 
         [Tooltip("The axis the slider moves along")]
         [SerializeField]
         private SliderAxis sliderAxis = SliderAxis.XAxis;
-        [Serializable]
-        private enum SliderAxis
+        /// <summary>
+        /// Property accessor of sliderAxis. The axis the slider moves along.
+        /// </summary>
+        public SliderAxis CurrentSliderAxis
         {
-            XAxis = 0,
-            YAxis,
-            ZAxis
+            get { return sliderAxis; }
+            set
+            {
+                sliderAxis = value;
+                UpdateVisualsOrientation();
+            }
+        }
+
+        /// <summary>
+        /// Previous value of slider axis, is used in order to detect change in current slider axis value
+        /// </summary>
+        private SliderAxis? previousSliderAxis = null;
+        /// <summary>
+        /// Property accessor for previousSliderAxis that is used also to initiallize the property with the current value in case of null value.
+        /// </summary>
+        private SliderAxis PreviousSliderAxis
+        {
+            get
+            {
+                if (previousSliderAxis == null)
+                {
+                    previousSliderAxis = CurrentSliderAxis;
+                }
+                return previousSliderAxis.Value;
+            }
+            set
+            {
+                previousSliderAxis = value;
+            }
         }
 
         [SerializeField]
@@ -144,15 +213,19 @@ public void Start()
             OnValueUpdated.Invoke(new SliderEventData(sliderValue, sliderValue, null, this));
         }
 
-
-
         private void OnDisable()
         {
             if (activePointer != null)
             {
                 EndInteraction();
             }
         }
+
+        private void OnValidate()
+        {
+            CurrentSliderAxis = sliderAxis;
+        }
+
         #endregion
 
         #region Private Methods
@@ -165,6 +238,78 @@ private void InitializeSliderThumb()
             UpdateUI();
         }
 
+        /// <summary>
+        /// Update orientation of track visuals based on slider axis orientation
+        /// </summary>
+        private void UpdateTrackVisuals()
+        {
+            if (TrackVisuals)
+            {
+                TrackVisuals.transform.localPosition = Vector3.zero;
+
+                switch (sliderAxis)
+                {
+                    case SliderAxis.XAxis:
+                        TrackVisuals.transform.localRotation = Quaternion.identity;
+                        break;
+                    case SliderAxis.YAxis:
+                        TrackVisuals.transform.localRotation = Quaternion.Euler(0.0f, 0.0f, 90.0f);
+                        break;
+                    case SliderAxis.ZAxis:
+                        TrackVisuals.transform.localRotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update orientation of tick marks based on slider axis orientation
+        /// </summary>
+        private void UpdateTickMarks()
+        {
+            if (TickMarks)
+            {
+                TickMarks.transform.localPosition = Vector3.zero;
+                TickMarks.transform.localRotation = Quaternion.identity;
+
+                var grid = TickMarks.GetComponent<Utilities.GridObjectCollection>();
+                if (grid)
+                {
+                    // Update cellwidth or cellheight depending on what was the previous axis set to
+                    var previousAxis = grid.Layout;
+                    if (previousAxis == Utilities.LayoutOrder.Vertical)
+                    {
+                        grid.CellWidth = grid.CellHeight;
+                    }
+                    else
+                    {
+                        grid.CellHeight = grid.CellWidth;
+                    }
+
+                    grid.Layout = (sliderAxis == SliderAxis.YAxis) ? Utilities.LayoutOrder.Vertical : Utilities.LayoutOrder.Horizontal;
+                    grid.UpdateCollection();
+                }
+
+                if (sliderAxis == SliderAxis.ZAxis)
+                {
+                    TickMarks.transform.localRotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update orientation of the visual components of pinch slider
+        /// </summary>
+        private void UpdateVisualsOrientation()
+        {
+            if (PreviousSliderAxis != sliderAxis)
+            {
+                UpdateTrackVisuals();
+                UpdateTickMarks();
+                PreviousSliderAxis = sliderAxis;
+            }
+        }
+
         private Vector3 GetSliderAxis()
         {
             switch (sliderAxis)

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/Sliders/SliderAxis.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+
+namespace Microsoft.MixedReality.Toolkit.UI
+{
+    /// <summary>
+    /// Describes in which axis to orient the slider
+    /// </summary>
+    [Serializable]
+    public enum SliderAxis
+    {
+        XAxis = 0,
+        YAxis,
+        ZAxis
+    }
+}

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/Sliders/SliderAxis.cs.meta

@@ -173,6 +173,97 @@ public IEnumerator TestAssembeInteractableAndEventsRaised()
             GameObject.Destroy(pinchSliderObject);
         }
 
+        /// <summary>
+        /// Tests that pinch slider visuals can be null
+        /// </summary>
+        [UnityTest]
+        public IEnumerator TestNullVisuals()
+        {
+            GameObject pinchSliderObject;
+            PinchSlider slider;
+
+            // This should not throw exception
+            InstantiateDefaultSliderPrefab(Vector3.forward, Vector3.zero, out pinchSliderObject, out slider);
+
+            // Remove references to visuals
+            slider.TrackVisuals = null;
+            slider.TickMarks = null;
+
+            // Test that the slider still works
+            Debug.Assert(slider.SliderValue == 0.5, "Slider should have value 0.5 at start");
+            yield return DirectPinchAndMoveSlider(slider, 1.0f);
+            Debug.Assert(slider.SliderValue == 1.0, "Slider should have value 1.0 after being manipulated at start");
+
+            // clean up
+            GameObject.Destroy(pinchSliderObject);
+            yield return null;
+        }
+
+        /// <summary>
+        /// Tests that pinch slider visuals have the correct orientation after slider axis change
+        /// </summary>
+        [UnityTest]
+        public IEnumerator TestVisualsOrientation()
+        {
+            GameObject pinchSliderObject;
+            PinchSlider slider;
+
+            // This should not throw exception
+            InstantiateDefaultSliderPrefab(Vector3.forward, Vector3.zero, out pinchSliderObject, out slider);
+
+            var tickMarks = slider.TickMarks;
+            var trackVisuals = slider.TrackVisuals;
+
+            slider.CurrentSliderAxis = SliderAxis.XAxis;
+
+            yield return null;
+
+            if (trackVisuals)
+            {
+                Debug.Assert(trackVisuals.transform.localRotation == Quaternion.identity, "TrackVisuals should have local rotation equal to Quaternion.identity");
+            }
+
+            if (tickMarks)
+            {
+                Debug.Assert(tickMarks.transform.localRotation == Quaternion.identity, "TickMarks should have local rotation equal to Quaternion.identity");
+                Debug.Assert(tickMarks.GetComponent<GridObjectCollection>().Layout == LayoutOrder.Horizontal, "TickMarks GridObjectCollection Layout should be Horizontal");
+            }
+
+            slider.CurrentSliderAxis = SliderAxis.YAxis;
+
+            yield return null;
+
+            if (trackVisuals)
+            {
+                Debug.Assert(trackVisuals.transform.localRotation == Quaternion.Euler(0.0f, 0.0f, 90.0f), "TrackVisuals should have local rotation equal to Quaternion.Euler(0.0f, 0.0f, 90.0f)");
+            }
+
+            if (tickMarks)
+            {
+                Debug.Assert(tickMarks.transform.localRotation == Quaternion.identity, "TickMarks should have local rotation equal to Quaternion.identity");
+                Debug.Assert(tickMarks.GetComponent<GridObjectCollection>().Layout == LayoutOrder.Vertical, "TickMarks GridObjectCollection Layout should be Vertical");
+            }
+
+            slider.CurrentSliderAxis = SliderAxis.ZAxis;
+
+            yield return null;
+
+            if (trackVisuals)
+            {
+                Debug.Assert(trackVisuals.transform.localRotation == Quaternion.Euler(0.0f, 90.0f, 0.0f), "TrackVisuals should have local rotation equal to Quaternion.Euler(0.0f, 90.0f, 0.0f)");
+            }
+
+            if (tickMarks)
+            {
+                Debug.Assert(tickMarks.transform.localRotation == Quaternion.Euler(0.0f, 90.0f, 0.0f), "TickMarks should have local rotation equal to Quaternion.Euler(0.0f, 90.0f, 0.0f)");
+                Debug.Assert(tickMarks.GetComponent<GridObjectCollection>().Layout == LayoutOrder.Horizontal, "TickMarks GridObjectCollection Layout should be Horizontal");
+            }
+
+            // clean up
+            GameObject.Destroy(pinchSliderObject);
+            yield return null;
+        }
+
         #endregion Tests
 
         #region Private methods

Assets/MixedRealityToolkit.Tests/PlayModeTests/PinchSliderTests.cs

@@ -42,3 +42,24 @@ You can directly move the starting and end points of the slider by moving the ha
 You can also specify the axis (in local space) of the slider via the _Slider Axis_ field
 
 If you cannot use the handles, you can instead specify the start and end points of the slider via the _Slider Start Distance_ and _Slider End Distance_ fields. These specify start / end position of slider as a distance from the slider's center, in local coordinates. This means that once you set the slider start and end distances as you want them, you can scale the slider to be smaller or larger without needing to update the start and end distances.
+
+## Inspector properties
+
+**Thumb Root** The gameobject that contains the slider thumb.
+
+**Slider Value** The value of the slider.
+
+**Track Visuals** The gameobject that contains the desired track visuals that goes along the slider.
+
+**Tick Marks** The gameobject that contains the desired tick marks that goes along the slider.
+
+**Slider Axis** The axis the slider moves along.
+
+**Slider Start Distance** Where the slider track starts, as distance from center along slider axis, in local space units.
+
+**Slider End Distance** Where the slider track ends, as distance from center along slider axis, in local space units.
+
+When user updates the slider axis value in editor then if Track Visuals or Tick Visuals are specified then their transform is updated. 
+Specifically, their local position is reset and their local rotation is set to match the Slider Axis orientation.
+Their scale isn't modified.
+If Tick Marks have a Grid Object Collection component then the Layout and CellWidth or CellHeight is updated accordingly to match the Slider Axis.