fr.jeanf.universal.player 0.7.3

package/Runtime/xrToolkit/Scripts/LocomotionConfigurationMenu.cs

@@ -0,0 +1,730 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.UI;
+
+namespace UnityEngine.XR.Interaction.Toolkit.Examples
+{
+    /// <summary>
+    /// Use this class to present locomotion control schemes and configuration preferences,
+    /// and respond to player input in the UI to set them.
+    /// </summary>
+    /// <seealso cref="LocomotionSchemeManager"/>
+    public class LocomotionConfigurationMenu : MonoBehaviour
+    {
+        class EnumDropdownCache<T> where T : Enum
+        {
+            public List<Dropdown.OptionData> options { get; } = new List<Dropdown.OptionData>();
+
+            readonly List<T> m_Values = new List<T>();
+
+            public EnumDropdownCache()
+            {
+                foreach (var name in Enum.GetNames(typeof(T)))
+                {
+                    options.Add(new Dropdown.OptionData(name));
+                }
+
+                foreach (var value in Enum.GetValues(typeof(T)))
+                {
+                    m_Values.Add((T)value);
+                }
+            }
+
+            public T GetValue(int index)
+            {
+                return m_Values[index];
+            }
+
+            public int FindIndex(T value)
+            {
+                // This will not distinguish between enums with duplicate values,
+                // and will always select the first equal value.
+                var comparer = EqualityComparer<T>.Default;
+                for (var index = 0; index < m_Values.Count; ++index)
+                {
+                    if (comparer.Equals(m_Values[index], value))
+                    {
+                        return index;
+                    }
+                }
+
+                return -1;
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Toggle used to enable or disable continuous movement locomotion.")]
+        Toggle m_ContinuousMoveToggle;
+        /// <summary>
+        /// Stores the <see cref="Toggle"/> used to enable or disable continuous movement locomotion.
+        /// </summary>
+        public Toggle continuousMoveToggle
+        {
+            get => m_ContinuousMoveToggle;
+            set
+            {
+                UnsubscribeContinuousMove(m_ContinuousMoveToggle);
+                m_ContinuousMoveToggle = value;
+                SubscribeContinuousMove(m_ContinuousMoveToggle);
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Slider used to set the move speed of continuous movement.")]
+        Slider m_MoveSpeedSlider;
+        /// <summary>
+        /// Stores the <see cref="Slider"/> used to set the move speed of continuous movement.
+        /// </summary>
+        public Slider moveSpeedSlider
+        {
+            get => m_MoveSpeedSlider;
+            set
+            {
+                UnsubscribeMoveSpeed(m_MoveSpeedSlider);
+                m_MoveSpeedSlider = value;
+                SubscribeMoveSpeed(m_MoveSpeedSlider, m_MoveSpeedValueText);
+                RefreshMoveDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Text used to display the current move speed of continuous movement.")]
+        Text m_MoveSpeedValueText;
+        /// <summary>
+        /// Stores the <see cref="Text"/> used to display the current move speed of continuous movement.
+        /// </summary>
+        public Text moveSpeedValueText
+        {
+            get => m_MoveSpeedValueText;
+            set
+            {
+                UnsubscribeMoveSpeed(m_MoveSpeedSlider);
+                m_MoveSpeedValueText = value;
+                SubscribeMoveSpeed(m_MoveSpeedSlider, m_MoveSpeedValueText);
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Toggle used to enable or disable strafing (sideways movement) of continuous movement.")]
+        Toggle m_EnableStrafeToggle;
+        /// <summary>
+        /// Stores the <see cref="Toggle"/> used to enable or disable strafing (sideways movement) of continuous movement.
+        /// </summary>
+        public Toggle enableStrafeToggle
+        {
+            get => m_EnableStrafeToggle;
+            set
+            {
+                UnsubscribeEnableStrafe(m_EnableStrafeToggle);
+                m_EnableStrafeToggle = value;
+                SubscribeEnableStrafe(m_EnableStrafeToggle);
+                RefreshMoveDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Toggle used to enable or disable gravity on continuous movement.")]
+        Toggle m_UseGravityToggle;
+        /// <summary>
+        /// Stores the <see cref="Toggle"/> used to enable or disable gravity on continuous movement.
+        /// </summary>
+        public Toggle useGravityToggle
+        {
+            get => m_UseGravityToggle;
+            set
+            {
+                UnsubscribeUseGravity(m_UseGravityToggle);
+                m_UseGravityToggle = value;
+                SubscribeUseGravity(m_UseGravityToggle);
+                RefreshMoveDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Dropdown used to select when gravity is applied with continuous movement.")]
+        Dropdown m_GravityApplicationModeDropdown;
+        /// <summary>
+        /// Stores the <see cref="Dropdown"/> used to select when gravity is applied with continuous movement.
+        /// </summary>
+        public Dropdown gravityApplicationModeDropdown
+        {
+            get => m_GravityApplicationModeDropdown;
+            set
+            {
+                UnsubscribeGravityApplicationMode(m_GravityApplicationModeDropdown);
+                m_GravityApplicationModeDropdown = value;
+                SubscribeGravityApplicationMode(m_GravityApplicationModeDropdown);
+                RefreshMoveDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Dropdown used to select the source Transform to define the forward direction of continuous movement.")]
+        Dropdown m_ForwardSourceDropdown;
+        /// <summary>
+        /// Stores the <see cref="Dropdown"/> used to select the source <see cref="Transform"/> to define the forward direction of continuous movement.
+        /// </summary>
+        public Dropdown forwardSourceDropdown
+        {
+            get => m_ForwardSourceDropdown;
+            set
+            {
+                UnsubscribeForwardSource(m_ForwardSourceDropdown);
+                m_ForwardSourceDropdown = value;
+                SubscribeForwardSource(m_ForwardSourceDropdown);
+                RefreshMoveDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Toggle used to enable or disable continuous turn locomotion.")]
+        Toggle m_ContinuousTurnToggle;
+        /// <summary>
+        /// Stores the <see cref="Toggle"/> used to enable or disable continuous turn locomotion.
+        /// </summary>
+        public Toggle continuousTurnToggle
+        {
+            get => m_ContinuousTurnToggle;
+            set
+            {
+                UnsubscribeContinuousTurn(m_ContinuousTurnToggle);
+                m_ContinuousTurnToggle = value;
+                SubscribeContinuousTurn(m_ContinuousTurnToggle);
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Slider used to set the turn speed of continuous turning.")]
+        Slider m_TurnSpeedSlider;
+        /// <summary>
+        /// Stores the <see cref="Slider"/> used to set the turn speed of continuous turning.
+        /// </summary>
+        public Slider turnSpeedSlider
+        {
+            get => m_TurnSpeedSlider;
+            set
+            {
+                UnsubscribeTurnSpeed(m_TurnSpeedSlider);
+                m_TurnSpeedSlider = value;
+                SubscribeTurnSpeed(m_TurnSpeedSlider, m_TurnSpeedValueText);
+                RefreshTurnDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Text used to display the current turn speed of continuous turning.")]
+        Text m_TurnSpeedValueText;
+        /// <summary>
+        /// Stores the <see cref="Text"/> used to display the current turn speed of continuous turning.
+        /// </summary>
+        public Text turnSpeedValueText
+        {
+            get => m_TurnSpeedValueText;
+            set
+            {
+                UnsubscribeTurnSpeed(m_TurnSpeedSlider);
+                m_TurnSpeedValueText = value;
+                SubscribeTurnSpeed(m_TurnSpeedSlider, m_TurnSpeedValueText);
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Dropdown used to select the number of degrees to rotate for snap turning.")]
+        Dropdown m_SnapTurnAmountDropdown;
+        /// <summary>
+        /// Stores the <see cref="Dropdown"/> used to select the number of degrees to rotate for snap turning.
+        /// </summary>
+        public Dropdown snapTurnAmountDropdown
+        {
+            get => m_SnapTurnAmountDropdown;
+            set
+            {
+                UnsubscribeSnapTurnAmount(m_SnapTurnAmountDropdown);
+                m_SnapTurnAmountDropdown = value;
+                SubscribeSnapTurnAmount(m_SnapTurnAmountDropdown);
+                RefreshTurnDependentInteractable();
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the Toggle used to enable or disable 180° snap turns.")]
+        Toggle m_EnableTurnAroundToggle;
+        /// <summary>
+        /// Stores the <see cref="Toggle"/> used to enable or disable 180° snap turns.
+        /// </summary>
+        public Toggle enableTurnAroundToggle
+        {
+            get => m_EnableTurnAroundToggle;
+            set
+            {
+                UnsubscribeEnableTurnAround(m_EnableTurnAroundToggle);
+                m_EnableTurnAroundToggle = value;
+                SubscribeEnableTurnAround(m_EnableTurnAroundToggle);
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Stores the behavior that will be used to configure locomotion control schemes and configuration preferences.")]
+        LocomotionSchemeManager m_Manager;
+        /// <summary>
+        /// Stores the behavior that will be used to configure locomotion control schemes and configuration preferences.
+        /// </summary>
+        public LocomotionSchemeManager manager
+        {
+            get => m_Manager;
+            set
+            {
+                UnsubscribeAll();
+                m_Manager = value;
+                if (m_Manager != null)
+                {
+                    SubscribeAll();
+                    RefreshInteractable();
+                }
+            }
+        }
+
+        static readonly List<float> k_SnapTurnAmounts = new List<float> { 15f, 30f, 45f, 60f, 75f, 90f };
+
+        static readonly List<Dropdown.OptionData> k_SnapTurnAmountOptions = new List<Dropdown.OptionData>(k_SnapTurnAmounts.Count);
+
+        static EnumDropdownCache<ContinuousMoveProviderBase.GravityApplicationMode> s_GravityApplicationModeDropdownCache;
+
+        static EnumDropdownCache<LocomotionSchemeManager.MoveForwardSource> s_ForwardSourceDropdownCache;
+
+        protected void Awake()
+        {
+            // Initialize Dropdown options for Snap Turn Amount
+            if (k_SnapTurnAmountOptions.Count != k_SnapTurnAmounts.Count)
+            {
+                foreach (var value in k_SnapTurnAmounts)
+                {
+                    k_SnapTurnAmountOptions.Add(new Dropdown.OptionData($"{value}°"));
+                }
+            }
+
+            // Initialize Dropdown options for Gravity Application Mode
+            if (s_GravityApplicationModeDropdownCache == null)
+            {
+                s_GravityApplicationModeDropdownCache = new EnumDropdownCache<ContinuousMoveProviderBase.GravityApplicationMode>();
+            }
+
+            // Initialize Dropdown options for Forward Source
+            if (s_ForwardSourceDropdownCache == null)
+            {
+                s_ForwardSourceDropdownCache = new EnumDropdownCache<LocomotionSchemeManager.MoveForwardSource>();
+            }
+        }
+
+        protected void OnEnable()
+        {
+            if (!ValidateManager())
+                return;
+
+            SubscribeAll();
+            RefreshInteractable();
+        }
+
+        protected void OnDisable()
+        {
+            UnsubscribeAll();
+        }
+
+        void SubscribeAll()
+        {
+            SubscribeContinuousMove(m_ContinuousMoveToggle);
+            SubscribeMoveSpeed(m_MoveSpeedSlider, m_MoveSpeedValueText);
+            SubscribeEnableStrafe(m_EnableStrafeToggle);
+            SubscribeUseGravity(m_UseGravityToggle);
+            SubscribeGravityApplicationMode(m_GravityApplicationModeDropdown);
+            SubscribeForwardSource(m_ForwardSourceDropdown);
+            SubscribeContinuousTurn(m_ContinuousTurnToggle);
+            SubscribeTurnSpeed(m_TurnSpeedSlider, m_TurnSpeedValueText);
+            SubscribeSnapTurnAmount(m_SnapTurnAmountDropdown);
+            SubscribeEnableTurnAround(m_EnableTurnAroundToggle);
+        }
+
+        void UnsubscribeAll()
+        {
+            UnsubscribeContinuousMove(m_ContinuousMoveToggle);
+            UnsubscribeMoveSpeed(m_MoveSpeedSlider);
+            UnsubscribeEnableStrafe(m_EnableStrafeToggle);
+            UnsubscribeUseGravity(m_UseGravityToggle);
+            UnsubscribeGravityApplicationMode(m_GravityApplicationModeDropdown);
+            UnsubscribeForwardSource(m_ForwardSourceDropdown);
+            UnsubscribeContinuousTurn(m_ContinuousTurnToggle);
+            UnsubscribeTurnSpeed(m_TurnSpeedSlider);
+            UnsubscribeSnapTurnAmount(m_SnapTurnAmountDropdown);
+            UnsubscribeEnableTurnAround(m_EnableTurnAroundToggle);
+        }
+
+        /// <summary>
+        /// Grey out input options that don't apply to the current control scheme.
+        /// </summary>
+        void RefreshInteractable()
+        {
+            if (!ValidateManager())
+                return;
+
+            RefreshMoveDependentInteractable();
+            RefreshTurnDependentInteractable();
+        }
+
+        void RefreshMoveDependentInteractable()
+        {
+            if (!ValidateManager())
+                return;
+
+            var continuousMove = m_Manager.moveScheme == LocomotionSchemeManager.MoveScheme.Continuous;
+            RefreshMoveDependentInteractable(continuousMove);
+        }
+
+        void RefreshMoveDependentInteractable(bool continuous)
+        {
+            if (m_MoveSpeedSlider != null)
+                m_MoveSpeedSlider.interactable = continuous;
+            if (m_EnableStrafeToggle != null)
+                m_EnableStrafeToggle.interactable = continuous;
+            if (m_UseGravityToggle != null)
+                m_UseGravityToggle.interactable = continuous;
+            if (m_GravityApplicationModeDropdown != null)
+                m_GravityApplicationModeDropdown.interactable = continuous;
+            if (m_ForwardSourceDropdown != null)
+                m_ForwardSourceDropdown.interactable = continuous;
+        }
+
+        void RefreshTurnDependentInteractable()
+        {
+            if (!ValidateManager())
+                return;
+
+            var continuousTurn = m_Manager.turnStyle == LocomotionSchemeManager.TurnStyle.Continuous;
+            RefreshTurnDependentInteractable(continuousTurn);
+        }
+
+        void RefreshTurnDependentInteractable(bool continuous)
+        {
+            if (m_TurnSpeedSlider != null)
+                m_TurnSpeedSlider.interactable = continuous;
+            if (m_SnapTurnAmountDropdown != null)
+                m_SnapTurnAmountDropdown.interactable = !continuous;
+        }
+
+        bool ValidateManager()
+        {
+            if (m_Manager == null)
+            {
+                Debug.LogError($"Reference to the {nameof(LocomotionSchemeManager)} is not set or the object has been destroyed," +
+                    " configuring locomotion settings from the menu will not be possible." +
+                    " Ensure the value has been set in the Inspector.", this);
+                return false;
+            }
+
+            if (m_Manager.continuousMoveProvider == null)
+            {
+                Debug.LogError($"Reference to the {nameof(ContinuousMoveProviderBase)} is not set or the object has been destroyed," +
+                    " configuring locomotion settings from the menu will not be possible." +
+                    $" Ensure the value has been set in the Inspector on {m_Manager}.", this);
+                return false;
+            }
+
+            if (m_Manager.continuousTurnProvider == null)
+            {
+                Debug.LogError($"Reference to the {nameof(ContinuousTurnProviderBase)} is not set or the object has been destroyed," +
+                    " configuring locomotion settings from the menu will not be possible." +
+                    $" Ensure the value has been set in the Inspector on {m_Manager}.", this);
+                return false;
+            }
+
+            if (m_Manager.snapTurnProvider == null)
+            {
+                Debug.LogError($"Reference to the {nameof(SnapTurnProviderBase)} is not set or the object has been destroyed," +
+                    " configuring locomotion settings from the menu will not be possible." +
+                    $" Ensure the value has been set in the Inspector on {m_Manager}.", this);
+                return false;
+            }
+
+            return true;
+        }
+
+        void SubscribeContinuousMove(Toggle toggle)
+        {
+            if (toggle == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            var continuousMove = m_Manager.moveScheme == LocomotionSchemeManager.MoveScheme.Continuous;
+            toggle.isOn = continuousMove;
+            toggle.onValueChanged.AddListener(OnContinuousMoveToggleValueChanged);
+        }
+
+        void SubscribeMoveSpeed(Slider slider, Text valueText)
+        {
+            if (slider == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            var currentMoveSpeed = m_Manager.continuousMoveProvider.moveSpeed;
+            if (currentMoveSpeed < slider.minValue || currentMoveSpeed > slider.maxValue)
+            {
+                Debug.LogError($"Move speed {currentMoveSpeed} is outside [{slider.minValue}, {slider.maxValue}] range of slider.");
+            }
+
+            slider.value = currentMoveSpeed;
+            if (valueText != null)
+            {
+                valueText.text = $"{currentMoveSpeed:F2}";
+            }
+
+            slider.onValueChanged.AddListener(OnMoveSpeedSliderValueChanged);
+        }
+
+        void SubscribeEnableStrafe(Toggle toggle)
+        {
+            if (toggle == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            toggle.isOn = m_Manager.continuousMoveProvider.enableStrafe;
+            toggle.onValueChanged.AddListener(OnEnableStrafeToggleValueChanged);
+        }
+
+        void SubscribeUseGravity(Toggle toggle)
+        {
+            if (toggle == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            toggle.isOn = m_Manager.continuousMoveProvider.useGravity;
+            toggle.onValueChanged.AddListener(OnUseGravityToggleValueChanged);
+        }
+
+        void SubscribeGravityApplicationMode(Dropdown dropdown)
+        {
+            if (dropdown == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            dropdown.options = s_GravityApplicationModeDropdownCache.options;
+            dropdown.value = s_GravityApplicationModeDropdownCache.FindIndex(m_Manager.continuousMoveProvider.gravityApplicationMode);
+            dropdown.onValueChanged.AddListener(OnGravityApplicationModeDropdownValueChanged);
+        }
+
+        void SubscribeForwardSource(Dropdown dropdown)
+        {
+            if (dropdown == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            dropdown.options = s_ForwardSourceDropdownCache.options;
+            dropdown.value = s_ForwardSourceDropdownCache.FindIndex(m_Manager.moveForwardSource);
+            dropdown.onValueChanged.AddListener(OnForwardSourceDropdownValueChanged);
+        }
+
+        void SubscribeContinuousTurn(Toggle toggle)
+        {
+            if (toggle == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            var continuousTurn = m_Manager.turnStyle == LocomotionSchemeManager.TurnStyle.Continuous;
+            toggle.isOn = continuousTurn;
+            toggle.onValueChanged.AddListener(OnContinuousTurnToggleValueChanged);
+        }
+
+        void SubscribeTurnSpeed(Slider slider, Text valueText)
+        {
+            if (slider == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            var currentTurnSpeed = m_Manager.continuousTurnProvider.turnSpeed;
+            if (currentTurnSpeed < slider.minValue || currentTurnSpeed > slider.maxValue)
+            {
+                Debug.LogError($"Turn speed {currentTurnSpeed} is outside [{slider.minValue}, {slider.maxValue}] range of slider.");
+            }
+
+            slider.value = currentTurnSpeed;
+            if (valueText != null)
+            {
+                valueText.text = currentTurnSpeed.ToString();
+            }
+
+            slider.onValueChanged.AddListener(OnTurnSpeedSliderValueChanged);
+        }
+
+        void SubscribeSnapTurnAmount(Dropdown dropdown)
+        {
+            if (dropdown == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            dropdown.options = k_SnapTurnAmountOptions;
+            var currentTurnAmount = m_Manager.snapTurnProvider.turnAmount;
+
+            // Find the index of the current turn amount within the options list of the Dropdown
+            var snapTurnIndex = -1;
+            for (var index = 0; index < k_SnapTurnAmounts.Count; ++index)
+            {
+                var value = k_SnapTurnAmounts[index];
+                if (Mathf.Approximately(value, currentTurnAmount))
+                {
+                    snapTurnIndex = index;
+                    break;
+                }
+            }
+
+            if (snapTurnIndex < 0)
+            {
+                Debug.LogError($"Turn amount {currentTurnAmount} is not contained within options list {{{string.Join(", ", k_SnapTurnAmounts)}}}", this);
+            }
+            else
+            {
+                dropdown.value = snapTurnIndex;
+            }
+
+            dropdown.onValueChanged.AddListener(OnSnapTurnAmountDropdownValueChanged);
+        }
+
+        void SubscribeEnableTurnAround(Toggle toggle)
+        {
+            if (toggle == null)
+                return;
+            if (!ValidateManager())
+                return;
+
+            toggle.isOn = m_Manager.snapTurnProvider.enableTurnAround;
+            toggle.onValueChanged.AddListener(OnEnableTurnAroundToggleValueChanged);
+        }
+
+        void UnsubscribeContinuousMove(Toggle toggle)
+        {
+            if (toggle != null)
+                toggle.onValueChanged.RemoveListener(OnContinuousMoveToggleValueChanged);
+        }
+
+        void UnsubscribeMoveSpeed(Slider slider)
+        {
+            if (slider != null)
+                slider.onValueChanged.RemoveListener(OnMoveSpeedSliderValueChanged);
+        }
+
+        void UnsubscribeEnableStrafe(Toggle toggle)
+        {
+            if (toggle != null)
+                toggle.onValueChanged.RemoveListener(OnEnableStrafeToggleValueChanged);
+        }
+
+        void UnsubscribeUseGravity(Toggle toggle)
+        {
+            if (toggle != null)
+                toggle.onValueChanged.RemoveListener(OnUseGravityToggleValueChanged);
+        }
+
+        void UnsubscribeGravityApplicationMode(Dropdown dropdown)
+        {
+            if (dropdown != null)
+                dropdown.onValueChanged.RemoveListener(OnGravityApplicationModeDropdownValueChanged);
+        }
+
+        void UnsubscribeForwardSource(Dropdown dropdown)
+        {
+            if (dropdown != null)
+                dropdown.onValueChanged.RemoveListener(OnForwardSourceDropdownValueChanged);
+        }
+
+        void UnsubscribeContinuousTurn(Toggle toggle)
+        {
+            if (toggle != null)
+                toggle.onValueChanged.RemoveListener(OnContinuousTurnToggleValueChanged);
+        }
+
+        void UnsubscribeTurnSpeed(Slider slider)
+        {
+            if (slider != null)
+                slider.onValueChanged.RemoveListener(OnTurnSpeedSliderValueChanged);
+        }
+
+        void UnsubscribeSnapTurnAmount(Dropdown dropdown)
+        {
+            if (dropdown != null)
+                dropdown.onValueChanged.RemoveListener(OnSnapTurnAmountDropdownValueChanged);
+        }
+
+        void UnsubscribeEnableTurnAround(Toggle toggle)
+        {
+            if (toggle != null)
+                toggle.onValueChanged.RemoveListener(OnEnableTurnAroundToggleValueChanged);
+        }
+
+        void OnContinuousMoveToggleValueChanged(bool value)
+        {
+            m_Manager.moveScheme = value
+                ? LocomotionSchemeManager.MoveScheme.Continuous
+                : LocomotionSchemeManager.MoveScheme.Noncontinuous;
+
+            RefreshMoveDependentInteractable(value);
+        }
+
+        void OnMoveSpeedSliderValueChanged(float value)
+        {
+            m_Manager.continuousMoveProvider.moveSpeed = value;
+            m_MoveSpeedValueText.text = $"{value:F2}";
+        }
+
+        void OnEnableStrafeToggleValueChanged(bool value)
+        {
+            m_Manager.continuousMoveProvider.enableStrafe = value;
+        }
+
+        void OnUseGravityToggleValueChanged(bool value)
+        {
+            m_Manager.continuousMoveProvider.useGravity = value;
+        }
+
+        void OnGravityApplicationModeDropdownValueChanged(int index)
+        {
+            m_Manager.continuousMoveProvider.gravityApplicationMode = s_GravityApplicationModeDropdownCache.GetValue(index);
+        }
+
+        void OnForwardSourceDropdownValueChanged(int index)
+        {
+            m_Manager.moveForwardSource = s_ForwardSourceDropdownCache.GetValue(index);
+        }
+
+        void OnContinuousTurnToggleValueChanged(bool value)
+        {
+            m_Manager.turnStyle = value
+                ? LocomotionSchemeManager.TurnStyle.Continuous
+                : LocomotionSchemeManager.TurnStyle.Snap;
+
+            RefreshTurnDependentInteractable(value);
+        }
+
+        void OnTurnSpeedSliderValueChanged(float value)
+        {
+            m_Manager.continuousTurnProvider.turnSpeed = value;
+            m_TurnSpeedValueText.text = value.ToString();
+        }
+
+        void OnSnapTurnAmountDropdownValueChanged(int index)
+        {
+            var turnAmount = k_SnapTurnAmounts[index];
+            m_Manager.snapTurnProvider.turnAmount = turnAmount;
+        }
+
+        void OnEnableTurnAroundToggleValueChanged(bool value)
+        {
+            m_Manager.snapTurnProvider.enableTurnAround = value;
+        }
+    }
+}