CrowdControl/Assets/Plugins/Animancer/Internal/Controller States/ControllerState.cs

// Animancer // Copyright 2020 Kybernetik //

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Playables;
using Object = UnityEngine.Object;

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.Animations;
#endif

namespace Animancer
{
    /// <summary>[Pro-Only]
    /// An <see cref="AnimancerState"/> which plays a <see cref="RuntimeAnimatorController"/>.
    /// You can control this state very similarly to an <see cref="Animator"/> via its <see cref="Playable"/> field.
    /// </summary>
    public class ControllerState : AnimancerState
    {
        /************************************************************************************************************************/
        #region Fields and Auto-Properties
        /************************************************************************************************************************/

        private RuntimeAnimatorController _Controller;

        /// <summary>The <see cref="RuntimeAnimatorController"/> which this state plays.</summary>
        public RuntimeAnimatorController Controller
        {
            get { return _Controller; }
            set
            {
                if (ReferenceEquals(_Controller, value))
                    return;

                if (ReferenceEquals(_Key, value))
                    Key = value;

                if (_Playable.IsValid())
                    Root._Graph.DestroyPlayable(_Playable);

                CreatePlayable(value);
                SetWeightDirty();
            }
        }

        /// <summary>The <see cref="RuntimeAnimatorController"/> which this state plays.</summary>
        public override Object MainObject
        {
            get { return Controller; }
            set { Controller = (RuntimeAnimatorController)value; }
        }

        /// <summary>The internal system which plays the <see cref="RuntimeAnimatorController"/>.</summary>
        public AnimatorControllerPlayable Playable { get; private set; }

        /************************************************************************************************************************/

        /// <summary>
        /// If false, <see cref="Stop"/> will reset all layers to their default state. Default False.
        /// <para></para>
        /// If you set this value to false after the constructor, you must assign the <see cref="DefaultStateHashes"/>
        /// or call <see cref="GatherDefaultStates"/> yourself.
        /// </summary>
        public bool KeepStateOnStop { get; set; }

        /// <summary>
        /// The <see cref="AnimatorStateInfo.shortNameHash"/> of the default state on each layer, used to reset to
        /// those states when <see cref="Stop"/> is called.
        /// </summary>
        public int[] DefaultStateHashes { get; set; }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Public API
        /************************************************************************************************************************/

        /// <summary>
        /// Constructs a new <see cref="ControllerState"/> to play the `animatorController` without connecting
        /// it to the <see cref="PlayableGraph"/>.
        /// </summary>
        protected ControllerState(AnimancerPlayable root, RuntimeAnimatorController animatorController,
            bool keepStateOnStop = false)
            : base(root)
        {
            KeepStateOnStop = keepStateOnStop;
            CreatePlayable(animatorController);
        }

        /// <summary>
        /// Constructs a new <see cref="ControllerState"/> to play the `animatorController` and connects it to
        /// the `layer`.
        /// </summary>
        public ControllerState(AnimancerLayer layer, RuntimeAnimatorController animatorController,
            bool keepStateOnStop = false)
            : this(layer.Root, animatorController, keepStateOnStop)
        {
            layer.AddChild(this);
        }

        /// <summary>
        /// Constructs a new <see cref="ControllerState"/> to play the `animatorController` and
        /// connects it to the `parent` at the specified `index`.
        /// </summary>
        public ControllerState(AnimancerNode parent, int index, RuntimeAnimatorController animatorController,
            bool keepStateOnStop = false)
            : this(parent.Root, animatorController, keepStateOnStop)
        {
            SetParent(parent, index);
        }

        /************************************************************************************************************************/

        private void CreatePlayable(RuntimeAnimatorController animatorController)
        {
            if (animatorController == null)
                throw new ArgumentNullException("animatorController");

            _Controller = animatorController;
            Playable = AnimatorControllerPlayable.Create(Root._Graph, animatorController);
            _Playable = Playable;

            if (!KeepStateOnStop)
                GatherDefaultStates();
        }

        /************************************************************************************************************************/

        /// <summary>
        /// The current state on layer 0, or the next state if it is currently in a transition.
        /// </summary>
        public AnimatorStateInfo StateInfo
        {
            get
            {
                return Playable.IsInTransition(0) ?
                    Playable.GetNextAnimatorStateInfo(0) :
                    Playable.GetCurrentAnimatorStateInfo(0);
            }
        }

        /************************************************************************************************************************/

        /// <summary>
        /// The <see cref="AnimatorStateInfo.normalizedTime"/> * <see cref="AnimatorStateInfo.length"/> of the
        /// <see cref="StateInfo"/>
        /// </summary>
        protected override float NewTime
        {
            get
            {
                var info = StateInfo;
                return info.normalizedTime * info.length;
            }
            set
            {
                Playable.PlayInFixedTime(0, 0, value);
            }
        }

        /************************************************************************************************************************/

        /// <summary>The current <see cref="AnimatorStateInfo.length"/> (on layer 0).</summary>
        public override float Length { get { return StateInfo.length; } }

        /************************************************************************************************************************/

        /// <summary>
        /// Indicates whether the current state on layer 0 will loop back to the start when it reaches the end.
        /// </summary>
        public override bool IsLooping { get { return StateInfo.loop; } }

        /************************************************************************************************************************/

        /// <summary>
        /// Gathers the <see cref="DefaultStateHashes"/> from the current states.
        /// </summary>
        public void GatherDefaultStates()
        {
            var layerCount = Playable.GetLayerCount();
            if (DefaultStateHashes == null || DefaultStateHashes.Length != layerCount)
                DefaultStateHashes = new int[layerCount];

            while (--layerCount >= 0)
                DefaultStateHashes[layerCount] = Playable.GetCurrentAnimatorStateInfo(layerCount).shortNameHash;
        }

        /// <summary>
        /// Calls the base <see cref="AnimancerState.Stop"/> and if <see cref="KeepStateOnStop"/> is false it also
        /// calls <see cref="ResetToDefaultStates"/>.
        /// </summary>
        public override void Stop()
        {
            base.Stop();
            if (!KeepStateOnStop)
                ResetToDefaultStates();
        }

        /// <summary>
        /// Resets all layers to their default state.
        /// </summary>
        /// <exception cref="NullReferenceException">Thrown if <see cref="DefaultStateHashes"/> is null.</exception>
        /// <exception cref="IndexOutOfRangeException">
        /// Thrown if the size of <see cref="DefaultStateHashes"/> is larger than the number of layers in the
        /// <see cref="Controller"/>.
        /// </exception>
        public void ResetToDefaultStates()
        {
            for (int i = 0; i < DefaultStateHashes.Length; i++)
                Playable.Play(DefaultStateHashes[i], i, 0);
        }

        /************************************************************************************************************************/

        /// <summary>
        /// Returns a string describing the type of this state and the name of the <see cref="Controller"/>.
        /// </summary>
        public override string ToString()
        {
            if (_Controller != null)
                return string.Concat(base.ToString(), " (", _Controller.name, ")");
            else
                return base.ToString() + " (null)";
        }

        /************************************************************************************************************************/

        /// <summary>[<see cref="IAnimationClipCollection"/>]
        /// Gathers all the animations in this state.
        /// </summary>
        public override void GatherAnimationClips(ICollection<AnimationClip> clips)
        {
            if (_Controller != null)
                clips.Gather(_Controller.animationClips);
        }

        /************************************************************************************************************************/

        /// <summary>Destroys the <see cref="Playable"/>.</summary>
        public override void Destroy()
        {
            _Controller = null;
            base.Destroy();
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Parameters
        /************************************************************************************************************************/

        /// <summary>
        /// A wrapper for the name and hash of an <see cref="AnimatorControllerParameter"/> to allow easy access.
        /// </summary>
        public struct Parameter
        {
            /************************************************************************************************************************/

            private string _Name;
            private int _Hash;

            /************************************************************************************************************************/

            /// <summary>
            /// The name of the wrapped parameter. This will be null if the <see cref="Hash"/> was assigned directly.
            /// </summary>
            public string Name
            {
                get { return _Name; }
                set
                {
                    _Name = value;
                    _Hash = Animator.StringToHash(value);
                }
            }

            /************************************************************************************************************************/

            /// <summary>
            /// The name hash of the wrapped parameter.
            /// </summary>
            public int Hash
            {
                get { return _Hash; }
                set
                {
                    _Name = null;
                    _Hash = value;
                }
            }

            /************************************************************************************************************************/

            /// <summary>
            /// Constructs a new <see cref="Parameter"/> with the specified <see cref="Name"/> and uses
            /// <see cref="Animator.StringToHash"/> to calculate the <see cref="Hash"/>.
            /// </summary>
            public Parameter(string name)
            {
                _Name = name;
                _Hash = Animator.StringToHash(name);
            }

            /// <summary>
            /// Constructs a new <see cref="Parameter"/> with the specified <see cref="Hash"/> and leaves the
            /// <see cref="Name"/> null.
            /// </summary>
            public Parameter(int hash)
            {
                _Name = null;
                _Hash = hash;
            }

            /************************************************************************************************************************/

            /// <summary>
            /// Constructs a new <see cref="Parameter"/> with the specified <see cref="Name"/> and uses
            /// <see cref="Animator.StringToHash"/> to calculate the <see cref="Hash"/>.
            /// </summary>
            public static implicit operator Parameter(string name)
            {
                return new Parameter(name);
            }

            /// <summary>
            /// Constructs a new <see cref="Parameter"/> with the specified <see cref="Hash"/> and leaves the
            /// <see cref="Name"/> null.
            /// </summary>
            public static implicit operator Parameter(int hash)
            {
                return new Parameter(hash);
            }

            /************************************************************************************************************************/

            /// <summary>Returns the <see cref="Hash"/>.</summary>
            public static implicit operator int(Parameter parameter)
            {
                return parameter._Hash;
            }

            /************************************************************************************************************************/

#if UNITY_EDITOR
            private static Dictionary<RuntimeAnimatorController, Dictionary<int, AnimatorControllerParameterType>>
                _ControllerToParameterHashAndType;
#endif

            /// <summary>[Editor-Conditional]
            /// Throws if the `controller` doesn't have a parameter with the specified <see cref="Hash"/>
            /// and `type`.
            /// </summary>
            /// <exception cref="ArgumentException"/>
            [System.Diagnostics.Conditional(Strings.EditorOnly)]
            public void ValidateHasParameter(RuntimeAnimatorController controller, AnimatorControllerParameterType type)
            {
#if UNITY_EDITOR
                if (_ControllerToParameterHashAndType == null)
                    _ControllerToParameterHashAndType = new Dictionary<RuntimeAnimatorController, Dictionary<int, AnimatorControllerParameterType>>();

                // Get the parameter details.
                Dictionary<int, AnimatorControllerParameterType> parameterDetails;
                if (!_ControllerToParameterHashAndType.TryGetValue(controller, out parameterDetails))
                {
                    parameterDetails = new Dictionary<int, AnimatorControllerParameterType>();

                    var animatorController = controller as AnimatorController;
                    var parameters = animatorController.parameters;
                    var count = parameters.Length;
                    for (int i = 0; i < count; i++)
                    {
                        var parameter = parameters[i];
                        parameterDetails.Add(parameter.nameHash, parameter.type);
                    }

                    _ControllerToParameterHashAndType.Add(controller, parameterDetails);
                }

                // Check that there is a parameter with the correct hash and type.

                AnimatorControllerParameterType parameterType;
                if (!parameterDetails.TryGetValue(_Hash, out parameterType))
                {
                    throw new ArgumentException(controller + " has no " + type + " parameter matching " + this);
                }

                if (type != parameterType)
                {
                    throw new ArgumentException(controller + " has a parameter matching " + this + ", but it is not a " + type);
                }
#endif
            }

            /************************************************************************************************************************/

            /// <summary>Returns a string containing the <see cref="Name"/> and <see cref="Hash"/>.</summary>
            public override string ToString()
            {
                return string.Concat(
                    "ControllerState.Parameter(Name:'",
                    _Name,
                    "', Hash:",
                    _Hash.ToString(),
                    ")");
            }

            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Inspector
        /************************************************************************************************************************/

        /// <summary>The number of parameters being wrapped by this state.</summary>
        public virtual int ParameterCount { get { return 0; } }

        /// <summary>Returns the hash of a parameter being wrapped by this state.</summary>
        /// <exception cref="NotSupportedException">Thrown if this state doesn't wrap any parameters.</exception>
        public virtual int GetParameterHash(int index) { throw new NotSupportedException(); }

        /************************************************************************************************************************/
#if UNITY_EDITOR
        /************************************************************************************************************************/

        /// <summary>[Editor-Only] Returns a <see cref="Drawer"/> for this state.</summary>
        protected internal override Editor.IAnimancerNodeDrawer GetDrawer()
        {
            return new Drawer(this);
        }

        /************************************************************************************************************************/

        /// <summary>[Editor-Only] Draws the Inspector GUI for an <see cref="ControllerState"/>.</summary>
        public sealed class Drawer : Editor.ParametizedAnimancerStateDrawer<ControllerState>
        {
            /************************************************************************************************************************/

            /// <summary>
            /// Constructs a new <see cref="Drawer"/> to manage the Inspector GUI for the `state`.
            /// </summary>
            public Drawer(ControllerState state) : base(state) { }

            /************************************************************************************************************************/

            /// <summary> Draws the details of the target state in the GUI.</summary>
            protected override void DoDetailsGUI(IAnimancerComponent owner)
            {
                GatherParameters();
                base.DoDetailsGUI(owner);
            }

            /************************************************************************************************************************/

            private readonly List<AnimatorControllerParameter>
                Parameters = new List<AnimatorControllerParameter>();

            /// <summary>
            /// Fills the <see cref="Parameters"/> list with the current parameter details.
            /// </summary>
            private void GatherParameters()
            {
                Parameters.Clear();

                var count = Target.ParameterCount;
                if (count == 0)
                    return;

                for (int i = 0; i < count; i++)
                {
                    var hash = Target.GetParameterHash(i);
                    Parameters.Add(GetParameter(hash));
                }
            }

            /************************************************************************************************************************/

            private AnimatorControllerParameter GetParameter(int hash)
            {
                var parameterCount = Target.Playable.GetParameterCount();
                for (int i = 0; i < parameterCount; i++)
                {
                    var parameter = Target.Playable.GetParameter(i);
                    if (parameter.nameHash == hash)
                        return parameter;
                }

                return null;
            }

            /************************************************************************************************************************/

            /// <summary>The number of parameters being managed by the target state.</summary>
            public override int ParameterCount { get { return Parameters.Count; } }

            /// <summary>Returns the name of a parameter being managed by the target state.</summary>
            /// <exception cref="NotSupportedException">Thrown if the target state doesn't manage any parameters.</exception>
            public override string GetParameterName(int index) { return Parameters[index].name; }

            /// <summary>Returns the type of a parameter being managed by the target state.</summary>
            /// <exception cref="NotSupportedException">Thrown if the target state doesn't manage any parameters.</exception>
            public override AnimatorControllerParameterType GetParameterType(int index) { return Parameters[index].type; }

            /// <summary>Returns the value of a parameter being managed by the target state.</summary>
            /// <exception cref="NotSupportedException">Thrown if the target state doesn't manage any parameters.</exception>
            public override object GetParameterValue(int index)
            {
                return Editor.AnimancerEditorUtilities.GetParameterValue(Target.Playable, Parameters[index]);
            }

            /// <summary>Sets the value of a parameter being managed by the target state.</summary>
            /// <exception cref="NotSupportedException">Thrown if the target state doesn't manage any parameters.</exception>
            public override void SetParameterValue(int index, object value)
            {
                Editor.AnimancerEditorUtilities.SetParameterValue(Target.Playable, Parameters[index], value);
            }

            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/
#endif
        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Transition
        /************************************************************************************************************************/

        /// <summary>
        /// Base class for serializable <see cref="ITransition"/>s which can create a particular type of
        /// <see cref="ControllerState"/> when passed into <see cref="AnimancerPlayable.Play(ITransition)"/>.
        /// </summary>
        /// <remarks>
        /// Unfortunately the tool used to generate this documentation does not currently support nested types with
        /// identical names, so only one <c>Transition</c> class will actually have a documentation page.
        /// <para></para>
        /// Even though it has the <see cref="SerializableAttribute"/>, this class won't actually get serialized
        /// by Unity because it's generic and abstract. Each child class still needs to include the attribute.
        /// </remarks>
        [Serializable]
        public abstract new class Transition<TState> : AnimancerState.Transition<TState>, IAnimationClipCollection
            where TState : ControllerState
        {
            /************************************************************************************************************************/

            [SerializeField]
            private RuntimeAnimatorController _Controller;

            /// <summary>[<see cref="SerializeField"/>]
            /// The <see cref="ControllerState.Controller"/> that will be used for the created state.
            /// </summary>
            public RuntimeAnimatorController Controller
            {
                get { return _Controller; }
                set { _Controller = value; }
            }

            /************************************************************************************************************************/

            [SerializeField, Tooltip("If false, stopping this state will reset all its layers to their default state. Default False.")]
            private bool _KeepStateOnStop;

            /// <summary>[<see cref="SerializeField"/>]
            /// If false, <see cref="Stop"/> will reset all layers to their default state.
            /// <para></para>
            /// If you set this value to false after the constructor, you must assign the <see cref="DefaultStateHashes"/>
            /// or call <see cref="GatherDefaultStates"/> yourself.
            /// </summary>
            public bool KeepStateOnStop
            {
                get { return _KeepStateOnStop; }
                set { _KeepStateOnStop = value; }
            }

            /************************************************************************************************************************/

            /// <summary>[<see cref="ITransitionDetailed"/>]
            /// The maximum amount of time the animation is expected to take (in seconds).
            /// </summary>
            public override float MaximumDuration
            {
                get
                {
                    if (_Controller == null)
                        return 0;

                    var duration = 0f;

                    var clips = _Controller.animationClips;
                    for (int i = 0; i < clips.Length; i++)
                    {
                        var length = clips[i].length;
                        if (duration < length)
                            duration = length;
                    }

                    return duration;
                }
            }

            /************************************************************************************************************************/

            /// <summary>Returns the <see cref="Controller"/>.</summary>
            public static implicit operator RuntimeAnimatorController(Transition<TState> transition)
            {
                return transition != null ? transition.Controller : null;
            }

            /************************************************************************************************************************/

            /// <summary>Adds all clips in the <see cref="Controller"/> to the collection.</summary>
            void IAnimationClipCollection.GatherAnimationClips(ICollection<AnimationClip> clips)
            {
                if (_Controller != null)
                    clips.Gather(_Controller.animationClips);
            }

            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/

        /// <summary>
        /// A serializable <see cref="ITransition"/> which can create a <see cref="ControllerState"/> when
        /// passed into <see cref="AnimancerPlayable.Play(ITransition)"/>.
        /// <para></para>
        /// This class can be implicitly cast to and from <see cref="RuntimeAnimatorController"/>.
        /// </summary>
        [Serializable]
        public class Transition : Transition<ControllerState>
        {
            /************************************************************************************************************************/

            /// <summary>
            /// Creates and returns a new <see cref="ControllerState"/> connected to the `layer`.
            /// <para></para>
            /// This method also assigns it as the <see cref="AnimancerState.Transition{TState}.State"/>.
            /// </summary>
            public override ControllerState CreateState(AnimancerLayer layer)
            {
                return new ControllerState(layer, Controller, KeepStateOnStop);
            }

            /************************************************************************************************************************/

            /// <summary>Constructs a new <see cref="Transition"/>.</summary>
            public Transition() { }

            /// <summary>Constructs a new <see cref="Transition"/> with the specified Animator Controller.</summary>
            public Transition(RuntimeAnimatorController controller)
            {
                Controller = controller;
            }

            /************************************************************************************************************************/

            /// <summary>Constructs a new <see cref="Transition"/> with the specified Animator Controller.</summary>
            public static implicit operator Transition(RuntimeAnimatorController controller)
            {
                return new Transition(controller);
            }

            /************************************************************************************************************************/
            #region Drawer
#if UNITY_EDITOR
            /************************************************************************************************************************/

            /// <summary>
            /// [Editor-Only] Draws the Inspector GUI for a <see cref="Transition{TState}"/> or
            /// <see cref="Transition"/>.
            /// </summary>
            [CustomPropertyDrawer(typeof(Transition<>), true)]
            [CustomPropertyDrawer(typeof(Transition), true)]
            public class Drawer : Editor.TransitionDrawer
            {
                /************************************************************************************************************************/

                private readonly string[] Parameters;
                private readonly string[] ParameterPrefixes;

                /************************************************************************************************************************/

                /// <summary>Constructs a new <see cref="Drawer"/> without any parameters.</summary>
                public Drawer() : this(null) { }

                /// <summary>Constructs a new <see cref="Drawer"/> and sets the <see cref="Parameters"/>.</summary>
                public Drawer(params string[] parameters) : base("_Controller")
                {
                    Parameters = parameters;
                    if (parameters == null)
                        return;

                    ParameterPrefixes = new string[parameters.Length];

                    for (int i = 0; i < ParameterPrefixes.Length; i++)
                    {
                        ParameterPrefixes[i] = "." + parameters[i];
                    }
                }

                /************************************************************************************************************************/

                /// <summary>
                /// Draws the `property` GUI in relation to the `rootProperty` which was passed into
                /// <see cref="Editor.TransitionDrawer.OnGUI"/>.
                /// </summary>
                protected override void DoPropertyGUI(ref Rect area, SerializedProperty rootProperty, SerializedProperty property, GUIContent label)
                {
                    if (ParameterPrefixes != null)
                    {
                        var controllerProperty = rootProperty.FindPropertyRelative(MainPropertyName);
                        var controller = controllerProperty.objectReferenceValue as AnimatorController;
                        if (controller != null)
                        {
                            var path = property.propertyPath;

                            for (int i = 0; i < ParameterPrefixes.Length; i++)
                            {
                                if (path.EndsWith(ParameterPrefixes[i]))
                                {
                                    area.height = Editor.AnimancerGUI.LineHeight;
                                    DoParameterGUI(area, controller, property);
                                    return;
                                }
                            }
                        }
                    }

                    EditorGUI.BeginChangeCheck();

                    base.DoPropertyGUI(ref area, rootProperty, property, label);

                    // When the controller changes, validate all parameters.
                    if (EditorGUI.EndChangeCheck() &&
                        Parameters != null &&
                        property.propertyPath.EndsWith(MainPropertyPathSuffix))
                    {
                        var controller = property.objectReferenceValue as AnimatorController;
                        if (controller != null)
                        {
                            for (int i = 0; i < Parameters.Length; i++)
                            {
                                property = rootProperty.FindPropertyRelative(Parameters[i]);
                                var parameterName = property.stringValue;
                                if (!HasFloatParameter(controller, parameterName))
                                {
                                    parameterName = GetFirstFloatParameterName(controller);
                                    if (!string.IsNullOrEmpty(parameterName))
                                        property.stringValue = parameterName;
                                }
                            }
                        }
                    }
                }

                /************************************************************************************************************************/

                /// <summary>
                /// Draws a dropdown menu to select the name of a parameter in the `controller`.
                /// </summary>
                protected void DoParameterGUI(Rect area, AnimatorController controller, SerializedProperty property)
                {
                    var parameterName = property.stringValue;
                    var parameters = controller.parameters;

                    var label = Editor.AnimancerGUI.TempContent(property);
                    label = EditorGUI.BeginProperty(area, label, property);

                    var xMax = area.xMax;
                    area.width = EditorGUIUtility.labelWidth;
                    EditorGUI.PrefixLabel(area, label);

                    area.x += area.width;
                    area.xMax = xMax;

                    var color = GUI.color;
                    if (!HasFloatParameter(controller, parameterName))
                        GUI.color = Editor.AnimancerGUI.ErrorFieldColor;

                    var content = Editor.AnimancerGUI.TempContent(parameterName);
                    if (EditorGUI.DropdownButton(area, content, FocusType.Passive))
                    {
                        property = property.Copy();

                        var menu = new GenericMenu();

                        for (int i = 0; i < parameters.Length; i++)
                        {
                            var parameter = parameters[i];
                            Editor.AnimancerEditorUtilities.AddMenuItem(menu, parameter.name,
                                parameter.type == AnimatorControllerParameterType.Float, () =>
                                {
                                    Editor.Serialization.ForEachTarget(property, (targetProperty) =>
                                    {
                                        targetProperty.stringValue = parameter.name;
                                    });
                                });
                        }

                        if (menu.GetItemCount() == 0)
                            menu.AddDisabledItem(new GUIContent("No Parameters"));

                        menu.ShowAsContext();
                    }

                    GUI.color = color;

                    EditorGUI.EndProperty();
                }

                /************************************************************************************************************************/

                private static bool HasFloatParameter(AnimatorController controller, string name)
                {
                    if (string.IsNullOrEmpty(name))
                        return false;

                    var parameters = controller.parameters;

                    for (int i = 0; i < parameters.Length; i++)
                    {
                        var parameter = parameters[i];
                        if (parameter.type == AnimatorControllerParameterType.Float && name == parameters[i].name)
                        {
                            return true;
                        }
                    }

                    return false;
                }

                /************************************************************************************************************************/

                private static string GetFirstFloatParameterName(AnimatorController controller)
                {
                    var parameters = controller.parameters;

                    for (int i = 0; i < parameters.Length; i++)
                    {
                        var parameter = parameters[i];
                        if (parameter.type == AnimatorControllerParameterType.Float)
                        {
                            return parameter.name;
                        }
                    }

                    return "";
                }

                /************************************************************************************************************************/
            }

            /************************************************************************************************************************/
#endif
            #endregion
            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
    }
}