CrowdControl/Assets/Plugins/Animancer/Internal/Mixer States/ManualMixerState.cs

// Animancer // Copyright 2020 Kybernetik //

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

#if UNITY_EDITOR
using UnityEditor;
using UnityEditorInternal;
#endif

namespace Animancer
{
    /// <summary>[Pro-Only]
    /// An <see cref="AnimancerState"/> which blends multiple child states. Unlike other mixers, this class does not
    /// perform any automatic weight calculations, it simple allows you to control the weight of all states manually.
    /// <para></para>
    /// This mixer type is similar to the Direct Blend Type in Mecanim Blend Trees.
    /// </summary>
    public class ManualMixerState : MixerState
    {
        /************************************************************************************************************************/
        #region Properties
        /************************************************************************************************************************/

        /// <summary>The states managed by this mixer.</summary>
        public AnimancerState[] States { get; protected set; }

        /// <summary>The number of input ports in the <see cref="AnimationMixerPlayable"/>.</summary>
        public override int PortCount { get { return States.Length; } }

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

        /// <summary>Returns the <see cref="States"/> array.</summary>
        public override IList<AnimancerState> ChildStates { get { return States; } }

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

        /// <summary>
        /// The weighted average <see cref="AnimancerState.Time"/> of each child state according to their
        /// <see cref="AnimancerNode.Weight"/>.
        /// </summary>
        protected override float NewTime
        {
            get
            {
                var totalWeight = 0f;
                var normalizedTime = 0f;
                var length = 0f;

                var count = States.Length;
                while (--count >= 0)
                {
                    var state = States[count];
                    if (state != null)
                    {
                        var weight = state.Weight;
                        totalWeight += weight;
                        normalizedTime += state.NormalizedTime * weight;
                        length += state.Length * weight;
                    }
                }

                if (totalWeight == 0)
                    return 0;

                totalWeight = 1f / totalWeight;
                return normalizedTime * totalWeight * length * totalWeight;
            }
            set
            {
                var count = States.Length;

                if (value == 0)
                    goto ZeroTime;

                var length = Length;
                if (length == 0)
                    goto ZeroTime;

                value /= length;// Normalize.

                while (--count >= 0)
                {
                    var state = States[count];
                    if (state != null)
                        state.NormalizedTime = value;
                }

                return;

                // If the value is 0, we can set the child times slightly more efficiently.
                ZeroTime:
                while (--count >= 0)
                {
                    var state = States[count];
                    if (state != null)
                        state.Time = 0;
                }
            }
        }

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

        /// <summary>
        /// The weighted average <see cref="AnimancerState.Length"/> of each child state according to their
        /// <see cref="AnimancerNode.Weight"/>.
        /// </summary>
        public override float Length
        {
            get
            {
                var length = 0f;

                var childWeight = CalculateTotalChildWeight();
                if (childWeight == 0)
                    return 0;

                childWeight = 1f / childWeight;

                var count = States.Length;
                while (--count >= 0)
                {
                    var state = States[count];
                    if (state != null)
                        length += state.Length * state.Weight * childWeight;
                }

                return length;
            }
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Initialisation
        /************************************************************************************************************************/

        /// <summary>
        /// Constructs a new <see cref="LinearMixerState"/> without connecting it to the <see cref="PlayableGraph"/>.
        /// </summary>
        protected ManualMixerState(AnimancerPlayable root) : base(root) { }

        /// <summary>
        /// Constructs a new <see cref="LinearMixerState"/> and connects it to the `layer`.
        /// </summary>
        public ManualMixerState(AnimancerLayer layer) : base(layer) { }

        /// <summary>
        /// Constructs a new <see cref="LinearMixerState"/> and connects it to the `parent` at the specified
        /// `index`.
        /// </summary>
        public ManualMixerState(AnimancerNode parent, int index) : base(parent, index) { }

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

        /// <summary>
        /// Initialises this mixer with the specified number of ports which can be filled individually by <see cref="CreateState"/>.
        /// </summary>
        public virtual void Initialise(int portCount)
        {
            if (portCount <= 1)
                Debug.LogWarning(GetType() + " is being initialised with capacity <= 1. The purpose of a mixer is to mix multiple clips.");

            _Playable.SetInputCount(portCount);
            States = new AnimancerState[portCount];
        }

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

        /// <summary>
        /// Initialises this mixer with one state per clip.
        /// </summary>
        public void Initialise(params AnimationClip[] clips)
        {
            int count = clips.Length;
            _Playable.SetInputCount(count);

            if (count <= 1)
                Debug.LogWarning(GetType() + " is being initialised without multiple clips. The purpose of a mixer is to mix multiple clips.");

            States = new AnimancerState[count];

            for (int i = 0; i < count; i++)
            {
                var clip = clips[i];
                if (clip != null)
                    new ClipState(this, i, clip);
            }
        }

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

        /// <summary>
        /// Creates and returns a new <see cref="ClipState"/> to play the `clip` with this
        /// <see cref="MixerState"/> as its parent.
        /// </summary>
        public override ClipState CreateState(int index, AnimationClip clip)
        {
            var oldState = States[index];
            if (oldState != null)
            {
                // If the old state has the specified `clip`, return it.
                if (oldState.Clip == clip)
                {
                    return oldState as ClipState;
                }
                else// Otherwise destroy and replace it.
                {
                    oldState.Destroy();
                }
            }

            return base.CreateState(index, clip);
        }

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

        /// <summary>Connects the `state` to this mixer at its <see cref="AnimancerNode.Index"/>.</summary>
        protected internal override void OnAddChild(AnimancerState state)
        {
            OnAddChild(States, state);
        }

        /// <summary>Disconnects the `state` from this mixer at its <see cref="AnimancerNode.Index"/>.</summary>
        protected internal override void OnRemoveChild(AnimancerState state)
        {
            Validate.RemoveChild(state, States);
            States[state.Index] = null;
            state.DisconnectFromGraph();
        }

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

        /// <summary>
        /// Destroys the <see cref="Playable"/> of this mixer and its <see cref="States"/>.
        /// </summary>
        public override void Destroy()
        {
            DestroyChildren();
            base.Destroy();
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Child States
        /************************************************************************************************************************/

        /// <summary>
        /// Calculates the sum of the <see cref="AnimancerNode.Weight"/> of all child states.
        /// </summary>
        public float CalculateTotalChildWeight()
        {
            if (States == null)
                return 0;

            var total = 0f;

            var count = States.Length;
            while (--count >= 0)
            {
                var state = States[count];
                if (state != null)
                    total += state.Weight;
            }

            return total;
        }

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

        /// <summary>
        /// Destroys all <see cref="States"/> connected to this mixer. This operation cannot be undone.
        /// </summary>
        public void DestroyChildren()
        {
            if (States == null)
                return;

            var count = States.Length;
            while (--count >= 0)
            {
                var state = States[count];
                if (state != null)
                    state.Destroy();
            }

            States = null;
        }

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

        /// <summary>
        /// Does nothing. Manual mixers do not automatically recalculate their weights.
        /// </summary>
        public override void RecalculateWeights() { }

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

        /// <summary>
        /// Sets the weight of all states after the `previousIndex` to 0.
        /// </summary>
        protected void DisableRemainingStates(int previousIndex)
        {
            var count = States.Length;
            while (++previousIndex < count)
            {
                var state = States[previousIndex];
                if (state == null)
                    continue;

                state.Weight = 0;
            }
        }

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

        /// <summary>
        /// Returns the state at the specified `index` if it is not null, otherwise increments the index and checks
        /// again. Returns null if no state is found by the end of the <see cref="States"/> array.
        /// </summary>
        protected AnimancerState GetNextState(ref int index)
        {
            while (index < States.Length)
            {
                var state = States[index];
                if (state != null)
                    return state;

                index++;
            }

            return null;
        }

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

        /// <summary>
        /// Divides the weight of all states by the `totalWeight` so that they all add up to 1.
        /// </summary>
        protected void NormalizeWeights(float totalWeight)
        {
            if (totalWeight == 1)
                return;

            totalWeight = 1f / totalWeight;

            int count = States.Length;
            for (int i = 0; i < count; i++)
            {
                var state = States[i];
                if (state == null)
                    continue;

                state.Weight *= totalWeight;
            }
        }

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

        /// <summary>Gets a user-friendly key to identify the `state` in the Inspector.</summary>
        public override string GetDisplayKey(AnimancerState state)
        {
            return string.Concat("[", state.Index.ToString(), "]");
        }

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

        /// <summary>
        /// Base class for serializable <see cref="ITransition"/>s which can create a particular type of
        /// <see cref="ManualMixerState"/> 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<TMixer> : AnimancerState.Transition<TMixer>, IAnimationClipCollection
            where TMixer : ManualMixerState
        {
            /************************************************************************************************************************/

            [SerializeField, HideInInspector]
            private AnimationClip[] _Clips;

            /// <summary>[<see cref="SerializeField"/>]
            /// The <see cref="ClipState.Clip"/> to use for each state in the mixer.
            /// </summary>
            public AnimationClip[] Clips
            {
                get { return _Clips; }
                set { _Clips = value; }
            }

            [SerializeField, HideInInspector]
            private float[] _Speeds;

            /// <summary>[<see cref="SerializeField"/>]
            /// The <see cref="AnimancerNode.Speed"/> to use for each state in the mixer.
            /// <para></para>
            /// If the size of this array doesn't match the <see cref="Clips"/>, it will be ignored.
            /// </summary>
            public float[] Speeds
            {
                get { return _Speeds; }
                set { _Speeds = value; }
            }

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

            [SerializeField, HideInInspector]
            private bool[] _SynchroniseChildren;

            /// <summary>[<see cref="SerializeField"/>]
            /// The <see cref="MixerState.SynchroniseChildren"/> flags for each state in the mixer.
            /// <para></para>
            /// The array can be null or empty. Any elements not in the array will be treated as true.
            /// </summary>
            public bool[] SynchroniseChildren
            {
                get { return _SynchroniseChildren; }
                set { _SynchroniseChildren = value; }
            }

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

            /// <summary>[<see cref="ITransitionDetailed"/>]
            /// Returns true is any of the <see cref="Clips"/> are looping.
            /// </summary>
            public override bool IsLooping
            {
                get
                {
                    var count = _Clips.Length;
                    for (int i = 0; i < count; i++)
                    {
                        var clip = _Clips[i];
                        if (clip == null)
                            continue;

                        if (clip.isLooping)
                            return true;
                    }

                    return false;
                }
            }

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

                    var duration = 0f;
                    var hasSpeeds = _Speeds != null && _Speeds.Length == _Clips.Length;

                    for (int i = 0; i < _Clips.Length; i++)
                    {
                        var clip = _Clips[i];
                        if (clip == null)
                            continue;

                        var length = clip.length;

                        if (hasSpeeds)
                            length *= _Speeds[i];

                        if (duration < length)
                            duration = length;
                    }

                    return duration;
                }
            }

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

            /// <summary>
            /// Initialises the <see cref="AnimancerState.Transition{TState}.State"/> immediately after it is created.
            /// </summary>
            public virtual void InitialiseState()
            {
                State.Initialise(_Clips);

                if (_Speeds != null && _Speeds.Length == _Clips.Length)
                {
                    for (int i = 0; i < State.States.Length; i++)
                    {
                        State.States[i].Speed = _Speeds[i];
                    }
                }

                State.SynchroniseChildren = _SynchroniseChildren;
            }

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

            /// <summary>Adds the <see cref="Clips"/> to the collection.</summary>
            void IAnimationClipCollection.GatherAnimationClips(ICollection<AnimationClip> clips)
            {
                clips.Gather(_Clips);
            }

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

            /// <summary>[Editor-Only] Adds context menu functions for this transition.</summary>
            protected override void AddItemsToContextMenu(GenericMenu menu, SerializedProperty property,
                Editor.Serialization.PropertyAccessor accessor)
            {
                base.AddItemsToContextMenu(menu, property, accessor);
                Transition.Drawer.AddItemsToContextMenu(menu, property);
            }

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

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

        /// <summary>
        /// A serializable <see cref="ITransition"/> which can create a <see cref="ManualMixerState"/> 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.
        /// </remarks>
        [Serializable]
        public class Transition : Transition<ManualMixerState>
        {
            /************************************************************************************************************************/

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

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

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

                /// <summary>
                /// The property this drawer is currently drawing.
                /// <para></para>
                /// Normally each property has its own drawer, but arrays share a single drawer for all elements.
                /// </summary>
                public static SerializedProperty CurrentProperty { get; private set; }

                /// <summary>The <see cref="Transition{TState}.Clips"/> field.</summary>
                public static SerializedProperty CurrentClips { get; private set; }

                /// <summary>The <see cref="Transition{TState}.Speeds"/> field.</summary>
                public static SerializedProperty CurrentSpeeds { get; private set; }

                /// <summary>The <see cref="Transition{TState}.SynchroniseChildren"/> field.</summary>
                public static SerializedProperty CurrentSynchroniseChildren { get; private set; }

                private readonly Dictionary<string, ReorderableList>
                    PropertyPathToStates = new Dictionary<string, ReorderableList>();

                /// <summary>
                /// Gather the details of the `property`.
                /// <para></para>
                /// This method gets called by every <see cref="GetPropertyHeight"/> and <see cref="OnGUI"/> call since
                /// Unity uses the same <see cref="PropertyDrawer"/> instance for each element in a collection, so it
                /// needs to gather the details associated with the current property.
                /// </summary>
                protected virtual ReorderableList GatherDetails(SerializedProperty property)
                {
                    InitialiseMode(property);
                    GatherSubProperties(property);

                    var propertyPath = property.propertyPath;

                    ReorderableList states;
                    if (!PropertyPathToStates.TryGetValue(propertyPath, out states))
                    {
                        states = new ReorderableList(CurrentClips.serializedObject, CurrentClips)
                        {
                            drawHeaderCallback = DoStateListHeaderGUI,
                            elementHeightCallback = GetElementHeight,
                            drawElementCallback = DoElementGUI,
                            onAddCallback = OnAddElement,
                            onRemoveCallback = OnRemoveElement,
#if UNITY_2018_1_OR_NEWER
                            onReorderCallbackWithDetails = OnReorderList,
#else
                            onReorderCallback = OnReorderList,
                            onSelectCallback = OnListSelectionChanged,
#endif
                        };

                        PropertyPathToStates.Add(propertyPath, states);
                    }

                    return states;
                }

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

                /// <summary>
                /// Called every time a `property` is drawn to find the relevant child properties and store them to be
                /// used in <see cref="GetPropertyHeight"/> and <see cref="OnGUI"/>.
                /// </summary>
                protected virtual void GatherSubProperties(SerializedProperty property)
                {
                    GatherSubPropertiesStatic(property);
                }

                /// <summary>
                /// Called every time a `property` is drawn to find the relevant child properties and store them to be
                /// used in <see cref="GetPropertyHeight"/> and <see cref="OnGUI"/>.
                /// </summary>
                public static void GatherSubPropertiesStatic(SerializedProperty property)
                {
                    CurrentProperty = property;
                    CurrentClips = property.FindPropertyRelative("_Clips");
                    CurrentSpeeds = property.FindPropertyRelative("_Speeds");
                    CurrentSynchroniseChildren = property.FindPropertyRelative("_SynchroniseChildren");

                    if (CurrentSpeeds.arraySize != 0)
                        CurrentSpeeds.arraySize = CurrentClips.arraySize;
                }

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

                /// <summary>
                /// Calculates the number of vertical pixels the `property` will occupy when it is drawn.
                /// </summary>
                public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
                {
                    var height = EditorGUI.GetPropertyHeight(property, label);

                    if (property.isExpanded)
                    {
                        var states = GatherDetails(property);
                        height += Editor.AnimancerGUI.StandardSpacing + states.GetHeight();
                    }

                    return height;
                }

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

                /// <summary>
                /// Draws the root `property` GUI and calls
                /// <see cref="Editor.TransitionDrawer.DoPropertyGUI"/> for each of its children.
                /// </summary>
                public override void OnGUI(Rect area, SerializedProperty property, GUIContent label)
                {
                    var originalProperty = property.Copy();

                    base.OnGUI(area, property, label);

                    if (!originalProperty.isExpanded)
                        return;

                    var states = GatherDetails(originalProperty);

                    var indentLevel = EditorGUI.indentLevel;

                    area.yMin = area.yMax - states.GetHeight();

                    EditorGUI.indentLevel++;
                    area = EditorGUI.IndentedRect(area);

                    EditorGUI.indentLevel = 0;
                    states.DoList(area);

                    EditorGUI.indentLevel = indentLevel;

                    TryCollapseSpeeds();
                }

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

                /// <summary>Splits the specified `area` into separate sections.</summary>
                protected void SplitListRect(Rect area, out Rect animation, out Rect speed, out Rect sync)
                {
                    var spacing = Editor.AnimancerGUI.StandardSpacing;

                    area.width += 2;
                    sync = Editor.AnimancerGUI.StealFromRight(ref area, Editor.AnimancerGUI.ToggleWidth - spacing, spacing);
                    speed = Editor.AnimancerGUI.StealFromRight(ref area, 55, spacing);
                    animation = area;
                }

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

                /// <summary>Draws the headdings of the state list.</summary>
                protected virtual void DoStateListHeaderGUI(Rect area)
                {
                    Rect animationArea, speedArea, syncArea;
                    SplitListRect(area, out animationArea, out speedArea, out syncArea);

                    DoAnimationLabelGUI(animationArea);
                    DoSpeedLabelGUI(speedArea);
                    DoSyncLabelGUI(syncArea);
                }

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

                /// <summary>Draws an "Animation" label.</summary>
                protected static void DoAnimationLabelGUI(Rect area)
                {
                    EditorGUI.BeginProperty(area, GUIContent.none, CurrentClips);
                    GUI.Label(area, Editor.AnimancerGUI.TempContent("Animation",
                        "The animations that will be used for each child state"));
                    EditorGUI.EndProperty();
                }

                /// <summary>Draws a "Speed" label.</summary>
                protected static void DoSpeedLabelGUI(Rect area)
                {
                    EditorGUI.BeginProperty(area, GUIContent.none, CurrentSpeeds);
                    GUI.Label(area, Editor.AnimancerGUI.TempContent("Speed",
                        "Determines how fast each child state plays (Default = 1)"));
                    EditorGUI.EndProperty();
                }

                private static float _SyncLabelWidth;

                /// <summary>Draws a "Sync" label.</summary>
                protected static void DoSyncLabelGUI(Rect area)
                {
                    const string Text = "Sync";

                    if (_SyncLabelWidth == 0)
                        _SyncLabelWidth = Editor.AnimancerGUI.CalculateLabelWidth(Text);

                    if (area.width < _SyncLabelWidth)
                        area.xMin = area.xMax - _SyncLabelWidth;

                    EditorGUI.BeginProperty(area, GUIContent.none, CurrentSynchroniseChildren);
                    GUI.Label(area, Editor.AnimancerGUI.TempContent(Text,
                        "Determines which child states have their normalized times constantly synchronised"));
                    EditorGUI.EndProperty();
                }

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

                /// <summary>Calculates the height of the state at the specified `index`.</summary>
                protected virtual float GetElementHeight(int index)
                {
                    return Editor.AnimancerGUI.LineHeight;
                }

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

                /// <summary>Draws the GUI of the state at the specified `index`.</summary>
                private void DoElementGUI(Rect area, int index, bool isActive, bool isFocused)
                {
                    if (index < 0 || index > CurrentClips.arraySize)
                        return;

                    var clip = CurrentClips.GetArrayElementAtIndex(index);
                    var speed = CurrentSpeeds.arraySize > 0 ? CurrentSpeeds.GetArrayElementAtIndex(index) : null;
                    DoElementGUI(area, index, clip, speed);
                }

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

                /// <summary>Draws the GUI of the state at the specified `index`.</summary>
                protected virtual void DoElementGUI(Rect area, int index,
                    SerializedProperty clip, SerializedProperty speed)
                {
                    Rect animationArea, speedArea, syncArea;
                    SplitListRect(area, out animationArea, out speedArea, out syncArea);

                    DoElementGUI(animationArea, speedArea, syncArea, index, clip, speed);
                }

                /// <summary>Draws the GUI of the state at the specified `index`.</summary>
                protected void DoElementGUI(Rect animationArea, Rect speedArea, Rect syncArea, int index,
                    SerializedProperty clip, SerializedProperty speed)
                {
                    EditorGUI.PropertyField(animationArea, clip, GUIContent.none);

                    if (speed != null)
                    {
                        EditorGUI.PropertyField(speedArea, speed, GUIContent.none);
                    }
                    else
                    {
                        EditorGUI.BeginProperty(speedArea, GUIContent.none, CurrentSpeeds);

                        var value = EditorGUI.FloatField(speedArea, 1);
                        if (value != 1)
                        {
                            CurrentSpeeds.InsertArrayElementAtIndex(0);
                            CurrentSpeeds.GetArrayElementAtIndex(0).floatValue = 1;
                            CurrentSpeeds.arraySize = CurrentClips.arraySize;
                            CurrentSpeeds.GetArrayElementAtIndex(index).floatValue = value;
                        }

                        EditorGUI.EndProperty();
                    }

                    DoSyncToggleGUI(syncArea, index);
                }

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

                /// <summary>
                /// Draws a toggle to enable or disable <see cref="MixerState.SynchroniseChildren"/> for the child at
                /// the specified `index`.
                /// </summary>
                protected void DoSyncToggleGUI(Rect area, int index)
                {
                    var syncFlagCount = CurrentSynchroniseChildren.arraySize;

                    var property = CurrentSynchroniseChildren;
                    var enabled = true;

                    if (index < syncFlagCount)
                    {
                        property = property.GetArrayElementAtIndex(index);
                        enabled = property.boolValue;
                    }

                    EditorGUI.BeginChangeCheck();
                    EditorGUI.BeginProperty(area, GUIContent.none, property);

                    enabled = GUI.Toggle(area, enabled, GUIContent.none);

                    EditorGUI.EndProperty();
                    if (EditorGUI.EndChangeCheck())
                    {
                        if (index < syncFlagCount)
                        {
                            property.boolValue = enabled;

                            for (int i = syncFlagCount - 1; i >= 0; i--)
                            {
                                if (CurrentSynchroniseChildren.GetArrayElementAtIndex(i).boolValue)
                                    syncFlagCount = i;
                                else
                                    break;
                            }

                            CurrentSynchroniseChildren.arraySize = syncFlagCount;
                        }
                        else
                        {
                            property.arraySize = index + 1;

                            for (int i = syncFlagCount; i < index; i++)
                            {
                                property.GetArrayElementAtIndex(i).boolValue = true;
                            }

                            property.GetArrayElementAtIndex(index).boolValue = enabled;
                        }
                    }
                }

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

                /// <summary>
                /// Called when adding a new state to the list to ensure that any other relevant arrays have new
                /// elements added as well.
                /// </summary>
                protected virtual void OnAddElement(ReorderableList list)
                {
                    var index = CurrentClips.arraySize;
                    CurrentClips.InsertArrayElementAtIndex(index);

                    if (CurrentSpeeds.arraySize > 0)
                        CurrentSpeeds.InsertArrayElementAtIndex(index);
                }

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

                /// <summary>
                /// Called when removing a state from the list to ensure that any other relevant arrays have elements
                /// removed as well.
                /// </summary>
                protected virtual void OnRemoveElement(ReorderableList list)
                {
                    var index = list.index;

                    RemoveArrayElement(CurrentClips, index);

                    if (CurrentSpeeds.arraySize > 0)
                        RemoveArrayElement(CurrentSpeeds, index);
                }

                /// <summary>
                /// Removes the specified array element from the `property`.
                /// <para></para>
                /// If the element is not at its default value, the first call to
                /// <see cref="SerializedProperty.DeleteArrayElementAtIndex"/> will only reset it, so this method will
                /// call it again if necessary to ensure that it actually gets removed.
                /// </summary>
                protected static void RemoveArrayElement(SerializedProperty property, int index)
                {
                    var count = property.arraySize;
                    property.DeleteArrayElementAtIndex(index);
                    if (property.arraySize == count)
                        property.DeleteArrayElementAtIndex(index);
                }

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

                /// <summary>
                /// Called when reordering states in the list to ensure that any other relevant arrays have their
                /// corresponding elements reordered as well.
                /// </summary>
                protected virtual void OnReorderList(ReorderableList list, int oldIndex, int newIndex)
                {
                    CurrentSpeeds.MoveArrayElement(oldIndex, newIndex);
                }

#if !UNITY_2018_1_OR_NEWER
                private int _SelectedIndex;

                private void OnListSelectionChanged(ReorderableList list)
                {
                    _SelectedIndex = list.index;
                }

                private void OnReorderList(ReorderableList list)
                {
                    OnReorderList(list, _SelectedIndex, list.index);
                }
#endif

                /************************************************************************************************************************/
                #region Speeds
                /************************************************************************************************************************/

                /// <summary>
                /// Initialises every element in the <see cref="CurrentSpeeds"/> array from the `start` to the end of
                /// the array to contain a value of 1.
                /// </summary>
                public static void InitialiseSpeeds(int start)
                {
                    var count = CurrentSpeeds.arraySize;
                    while (start < count)
                        CurrentSpeeds.GetArrayElementAtIndex(start++).floatValue = 1;

                }

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

                /// <summary>
                /// If every element in the <see cref="CurrentSpeeds"/> array is 1, this method sets the array size to 0.
                /// </summary>
                public static void TryCollapseSpeeds()
                {
                    var speedCount = CurrentSpeeds.arraySize;
                    if (speedCount <= 0)
                        return;

                    for (int i = 0; i < speedCount; i++)
                    {
                        if (CurrentSpeeds.GetArrayElementAtIndex(i).floatValue != 1)
                            return;
                    }

                    CurrentSpeeds.arraySize = 0;
                }

                /************************************************************************************************************************/
                #endregion
                /************************************************************************************************************************/
                #region Context Menu
                /************************************************************************************************************************/

                /// <summary>[Editor-Only] Adds context menu functions for this transition.</summary>
                public static void AddItemsToContextMenu(GenericMenu menu, SerializedProperty property)
                {
                    GatherSubPropertiesStatic(property);

                    AddPropertyModifierFunction(menu, "Reset Speeds", (_) => CurrentSpeeds.arraySize = 0);
                    AddPropertyModifierFunction(menu, "Normalize Durations", NormalizeDurations);
                }

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

                /// <summary>
                /// Recalculates the <see cref="CurrentSpeeds"/> depending on the <see cref="AnimationClip.length"/> of
                /// their animations so that they all take the same amount of time to play fully.
                /// </summary>
                private static void NormalizeDurations(SerializedProperty property)
                {
                    var speedCount = CurrentSpeeds.arraySize;

                    var lengths = new float[CurrentClips.arraySize];
                    if (lengths.Length <= 1)
                        return;

                    int nonZeroLengths = 0;
                    float totalLength = 0;
                    float totalSpeed = 0;
                    for (int i = 0; i < lengths.Length; i++)
                    {
                        var clip = CurrentClips.GetArrayElementAtIndex(i).objectReferenceValue as AnimationClip;
                        if (clip != null && clip.length > 0)
                        {
                            nonZeroLengths++;
                            totalLength += clip.length;
                            lengths[i] = clip.length;

                            if (speedCount > 0)
                                totalSpeed += CurrentSpeeds.GetArrayElementAtIndex(i).floatValue;
                        }
                    }

                    if (nonZeroLengths == 0)
                        return;

                    var averageLength = totalLength / nonZeroLengths;
                    var averageSpeed = speedCount > 0 ? totalSpeed / nonZeroLengths : 1;

                    CurrentSpeeds.arraySize = lengths.Length;
                    InitialiseSpeeds(speedCount);

                    for (int i = 0; i < lengths.Length; i++)
                    {
                        if (lengths[i] == 0)
                            continue;

                        CurrentSpeeds.GetArrayElementAtIndex(i).floatValue = averageSpeed * lengths[i] / averageLength;
                    }

                    TryCollapseSpeeds();
                }

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

                /// <summary>
                /// Adds a menu function that will call <see cref="GatherSubPropertiesStatic"/> then perform the specified
                /// `action`.
                /// </summary>
                protected static void AddPropertyModifierFunction(GenericMenu menu, string label, Action<SerializedProperty> action)
                {
                    Editor.Serialization.AddPropertyModifierFunction(menu, CurrentProperty, label, (property) =>
                    {
                        GatherSubPropertiesStatic(property);
                        action(property);
                    });
                }

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

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

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