SliderGestureControl.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using HoloToolkit.Unity;
using UnityEngine;

namespace HoloToolkit.Examples.InteractiveElements
{
    public class SliderGestureControl : GestureInteractiveControl
    {
        [Tooltip("The main bar of the slider, used to get the actual width of the slider")]
        public GameObject SliderBar;
        [Tooltip("The visual marker of the slider value")]
        public GameObject Knob;
        [Tooltip("The fill that represents the volume of the shader value")]
        public GameObject SliderFill;
        [Tooltip("The text representation of the slider value")]
        public TextMesh Label;

        [Tooltip("Used for centered format only, will be turned off if LeftJustified")]
        public GameObject CenteredDot;

        [Tooltip("Sends slider event information on Update")]
        public UnityEventFloat OnUpdateEvent;

        public float SliderValue
        {
            private set
            {
                if (sliderValue != value)
                {
                    sliderValue = value;
                    OnUpdateEvent.Invoke(sliderValue);
                }
            }
            get
            {
                return sliderValue;
            }
        }

        [SerializeField]
        [Tooltip("Set the starting value for the slider here.")]
        private float sliderValue = 0;

        [Tooltip("Min numeric value to display in the slider label")]
        public float MinSliderValue = 0;

        [Tooltip("Max numeric value to display in the slider label")]
        public float MaxSliderValue = 1;

        [Tooltip("Switches between a left justified or centered slider")]
        public bool Centered = false;

        [Tooltip("Format the slider value and control decimal places if needed")]
        public string LabelFormat = "#.##";

        // calculation variables
        private float mValueSpan;
        private float mCachedValue;
        private float mDeltaValue;
        private Vector3 mStartCenter = new Vector3();
        private float mSliderMagnitude;
        private Vector3 mStartSliderPosition;

        // cached UI values
        private Vector3 mKnobVector;
        private Vector3 mSliderFillScale;
        private float mSliderWidth;

        private float autoSliderTime = 0.25f;
        private float autoSliderTimerCounter = 0.5f;
        private float autoSliderValue = 0;

        private Vector3 mSliderVector;
        private Quaternion mCachedRotation;

        protected override void Awake()
        {
            base.Awake();

            if (MinSliderValue >= MaxSliderValue)
            {
                Debug.LogError("Your SliderGestureControl has a min value that's greater than or equal to its max value.");
                gameObject.SetActive(false);
                return;
            }

            if (Centered && MinSliderValue != -MaxSliderValue)
            {
                Debug.LogError("A centered SliderGestureControl requires that the min and max values have the same absolute value, one positive and one negative.");
                gameObject.SetActive(false);
                return;
            }

            if (Knob != null)
            {
                mStartCenter.z = Knob.transform.localPosition.z;
            }

            mCachedRotation = SliderBar.transform.rotation;

            // with some better math below, I may be able to avoid rotating to get the proper size of the component

            SliderBar.transform.rotation = Quaternion.identity;

            // set the width of the slider 
            mSliderMagnitude = SliderBar.transform.InverseTransformVector(SliderBar.GetComponent<Renderer>().bounds.size).x;

            // set the center position
            mStartSliderPosition = mStartCenter + Vector3.left * mSliderMagnitude / 2;

            mValueSpan = MaxSliderValue - MinSliderValue;
            sliderValue = Mathf.Clamp(SliderValue, MinSliderValue, MaxSliderValue);

            if (!Centered)
            {
                mDeltaValue = (SliderValue - MinSliderValue) / mValueSpan;
            }
            else
            {
                mValueSpan = (MaxSliderValue - MinSliderValue) / 2;
                mDeltaValue = (SliderValue + mValueSpan) / 2 / mValueSpan;
            }

            mSliderFillScale = new Vector3(1, 1, 1);
            mSliderWidth = mSliderMagnitude;
            if (SliderFill != null)
            {
                mSliderFillScale = SliderFill.transform.localScale;
                mSliderWidth = SliderFill.transform.InverseTransformVector(SliderFill.GetComponent<Renderer>().bounds.size).x;
            }

            if (CenteredDot != null && !Centered)
            {
                CenteredDot.SetActive(false);
            }

            SliderBar.transform.rotation = mCachedRotation;

            UpdateVisuals();
            mCachedValue = mDeltaValue;

            mSliderVector = SliderBar.transform.InverseTransformPoint(mStartCenter + SliderBar.transform.right * mSliderMagnitude / 2) - SliderBar.transform.InverseTransformPoint(mStartCenter - SliderBar.transform.right * mSliderMagnitude / 2);
            AlignmentVector = SliderBar.transform.right;
            AlignmentVector = mSliderVector;
        }

        public override void ManipulationUpdate(Vector3 startGesturePosition, Vector3 currentGesturePosition, Vector3 startHeadOrigin, Vector3 startHeadRay, GestureInteractive.GestureManipulationState gestureState)
        {
            if (AlignmentVector != SliderBar.transform.right)
            {
                mSliderVector = SliderBar.transform.InverseTransformPoint(mStartCenter + SliderBar.transform.right * mSliderMagnitude / 2) - SliderBar.transform.InverseTransformPoint(mStartCenter - SliderBar.transform.right * mSliderMagnitude / 2);
                AlignmentVector = SliderBar.transform.right;

                mCachedRotation = SliderBar.transform.rotation;
            }

            base.ManipulationUpdate(startGesturePosition, currentGesturePosition, startHeadOrigin, startHeadRay, gestureState);

            // get the current delta
            float delta = (CurrentDistance > 0) ? CurrentPercentage : -CurrentPercentage;

            // combine the delta with the current slider position so the slider does not start over every time
            mDeltaValue = Mathf.Clamp01(delta + mCachedValue);

            if (!Centered)
            {
                SliderValue = mDeltaValue * mValueSpan + MinSliderValue;
            }
            else
            {
                SliderValue = mDeltaValue * mValueSpan * 2 - mValueSpan;
            }

            UpdateVisuals();

            if (gestureState == GestureInteractive.GestureManipulationState.None)
            {
                // gesture ended - cache the current delta
                mCachedValue = mDeltaValue;
            }
        }

        public override void setGestureValue(int gestureValue)
        {
            //base.setGestureValue(gestureValue);

            if (GestureStarted)
            {
                return;
            }

            switch (gestureValue)
            {
                case 0:
                    autoSliderValue = 0;
                    break;
                case 1:
                    autoSliderValue = 0.5f;
                    break;
                case 2:
                    autoSliderValue = 1;
                    break;
            }
            autoSliderTimerCounter = 0;
        }

        public void SetSpan(float min, float max)
        {
            mValueSpan = max - min;
            MaxSliderValue = max;
            MinSliderValue = min;
        }

        public void SetSliderValue(float value)
        {
            if (GestureStarted)
            {
                return;
            }

            SliderValue = Mathf.Clamp(value, MinSliderValue, MaxSliderValue);
            mDeltaValue = SliderValue / MaxSliderValue;
            UpdateVisuals();
            mCachedValue = mDeltaValue;
        }

        // update visuals
        private void UpdateVisuals()
        {
            // set the knob position
            mKnobVector = mStartSliderPosition + Vector3.right * mSliderMagnitude * mDeltaValue;
            mKnobVector.z = mStartCenter.z;

            // TODO: Add snapping!

            if (Knob != null)
            {
                Knob.transform.localPosition = mKnobVector;
            }

            // set the fill scale and position
            if (SliderFill != null)
            {
                Vector3 scale = mSliderFillScale;
                scale.x = mSliderFillScale.x * mDeltaValue;

                Vector3 position = Vector3.left * (mSliderWidth * 0.5f - mSliderWidth * mDeltaValue * 0.5f); // left justified;

                if (Centered)
                {
                    if (SliderValue < 0)
                    {
                        position = Vector3.left * (mSliderWidth * 0.5f - mSliderWidth * 0.5f * (mDeltaValue + 0.5f)); // pinned to center, going left
                        scale.x = mSliderFillScale.x * (1 - mDeltaValue / 0.5f) * 0.5f;
                    }
                    else
                    {
                        position = Vector3.right * ((mSliderWidth * 0.5f * (mDeltaValue - 0.5f))); // pinned to center, going right
                        scale.x = mSliderFillScale.x * ((mDeltaValue - 0.5f) / 0.5f) * 0.5f;
                    }
                }

                SliderFill.transform.localScale = scale;
                SliderFill.transform.localPosition = position;
            }

            // set the label
            if (Label != null)
            {
                if (LabelFormat.IndexOf('.') > -1)
                {
                    Label.text = SliderValue.ToString(LabelFormat);

                }
                else
                {
                    Label.text = Mathf.Round(SliderValue).ToString(LabelFormat);
                }
            }
        }

        protected override void Update()
        {
            base.Update();

            if (autoSliderTimerCounter < autoSliderTime)
            {
                if (GestureStarted)
                {
                    autoSliderTimerCounter = autoSliderTime;
                    return;
                }

                autoSliderTimerCounter += Time.deltaTime;
                if (autoSliderTimerCounter >= autoSliderTime)
                {
                    autoSliderTimerCounter = autoSliderTime;
                    mCachedValue = autoSliderValue;
                }

                mDeltaValue = (autoSliderValue - mCachedValue) * autoSliderTimerCounter / autoSliderTime + mCachedValue;

                if (!Centered)
                {
                    SliderValue = mDeltaValue * mValueSpan + MinSliderValue;
                }
                else
                {
                    SliderValue = mDeltaValue * mValueSpan * 2 - mValueSpan;
                }

                UpdateVisuals();
            }
        }
    }
}