CrowdControl/Assets/Plugins/Animancer/Internal/Core/AnimancerEvent.Sequence.Serializable.cs

// Animancer // Copyright 2020 Kybernetik //

#pragma warning disable CS0649 // Field is never assigned to, and will always have its default value.

//#define ANIMANCER_ULT_EVENTS

// If you edit this file to change the callback type to something other than UltEvents, you will need to change this
// alias as well as the HasPersistentCalls method below.
#if ANIMANCER_ULT_EVENTS
using SerializableCallback = UltEvents.UltEvent;
#else
using SerializableCallback = UnityEngine.Events.UnityEvent;
#endif

using UnityEngine;
using System;

namespace Animancer
{
    partial struct AnimancerEvent
    {
        partial class Sequence
        {
            /// <summary>
            /// An <see cref="AnimancerEvent.Sequence"/> that can be serialized and uses
            /// <see cref="SerializableCallback"/>s to define the <see cref="callback"/>s.
            /// </summary>
            /// <remarks>
            /// If you have Animancer Pro you can replace <see cref="SerializableCallback"/>s with
            /// <see href="https://kybernetik.com.au/ultevents">UltEvents</see> using the following procedure:
            /// <list type="number">
            /// <item>Select the <c>Assets/Plugins/Animancer/Animancer.asmdef</c> and add a Reference to the
            /// <c>UltEvents</c> Assembly Definition.</item>
            /// <item>Go into the Player Settings of your project and add <c>ANIMANCER_ULT_EVENTS</c> as a Scripting
            /// Define Symbol. Or you can simply edit this script to change the event type (it is located at
            /// <c>Assets/Plugins/Animancer/Internal/Core/AnimancerEvent.Sequence.Serializable.cs</c> by default.</item>
            /// </list>
            /// </remarks>
            [Serializable]
            public sealed class Serializable
#if UNITY_EDITOR
                : ISerializationCallbackReceiver
#endif
            {
                /************************************************************************************************************************/

                /// <summary>The serialized <see cref="normalizedTime"/>s.</summary>
                [SerializeField]
                private float[] _NormalizedTimes;

                /// <summary>The name of the array field which stores the <see cref="normalizedTime"/>s.</summary>
                public const string NormalizedTimesField = "_NormalizedTimes";

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

                /// <summary>The serialized <see cref="callback"/>s.</summary>
                /// <remarks>
                /// This array only needs to be large enough to hold the last event that actually contains any calls.
                /// Any empty or missing elements will simply use the <see cref="DummyCallback"/> at runtime.
                /// </remarks>
                [SerializeField]
                [UnityEngine.Serialization.FormerlySerializedAs("_Events")]
                private SerializableCallback[] _Callbacks;

                /// <summary>The name of the array field which stores the <see cref="callback"/>s.</summary>
                public const string Callbacks = "_Callbacks";

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

                private Sequence _Sequence;

                /// <summary>
                /// The runtime <see cref="AnimancerEvent.Sequence"/> compiled from this <see cref="Serializable"/>.
                /// Each call after the first will return the same value.
                /// <para></para>
                /// Unlike <see cref="GetSequenceOptional"/>, this method will create an empty
                /// <see cref="AnimancerEvent.Sequence"/> instead of returning null.
                /// </summary>
                public Sequence Sequence
                {
                    get
                    {
                        if (_Sequence == null)
                        {
                            GetSequenceOptional();

                            if (_Sequence == null)
                                _Sequence = new Sequence();
                        }
                        return _Sequence;
                    }
                    set { _Sequence = value; }
                }

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

                /// <summary>
                /// Returns the runtime <see cref="AnimancerEvent.Sequence"/> compiled from this
                /// <see cref="Serializable"/>. Each call after the first will return the same value.
                /// <para></para>
                /// This method returns null if the sequence would be empty anyway and is used by the implicit
                /// conversion from <see cref="Serializable"/> to <see cref="AnimancerEvent.Sequence"/>.
                /// </summary>
                public Sequence GetSequenceOptional()
                {
                    if (_Sequence != null ||
                        _NormalizedTimes == null)
                        return _Sequence;

                    var timeCount = _NormalizedTimes.Length;
                    if (timeCount == 0)
                        return null;

                    var callbackCount = _Callbacks.Length;

                    AnimancerEvent endEvent;
                    if (callbackCount >= timeCount--)
                    {
                        endEvent = new AnimancerEvent(_NormalizedTimes[timeCount], GetInvoker(_Callbacks[timeCount]));
                    }
                    else
                    {
                        endEvent = new AnimancerEvent(_NormalizedTimes[timeCount], null);
                    }

                    _Sequence = new Sequence(timeCount)
                    {
                        endEvent = endEvent,
                        Count = timeCount,
                    };

                    for (int i = 0; i < timeCount; i++)
                    {
                        var callback = i < callbackCount ? GetInvoker(_Callbacks[i]) : DummyCallback;
                        _Sequence._Events[i] = new AnimancerEvent(_NormalizedTimes[i], callback);
                    }

                    return _Sequence;
                }

                /// <summary>Calls <see cref="GetSequenceOptional"/>.</summary>
                public static implicit operator Sequence(Serializable serializable)
                {
                    return serializable != null ? serializable.GetSequenceOptional() : null;
                }

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

                /// <summary>
                /// A delegate that does nothing which is used whenever the <see cref="SerializableCallback"/> is not
                /// defined for a particular event or it is empty.
                /// </summary>
                public static readonly Action DummyCallback = () => { };

                /// <summary>
                /// If the `callback` has any persistent calls, this method returns a delegate to call its
                /// <see cref="SerializableCallback.Invoke"/> method. Otherwise it returns the
                /// <see cref="DummyCallback"/>.
                /// </summary>
                public static Action GetInvoker(SerializableCallback callback)
                {
                    return HasPersistentCalls(callback) ? callback.Invoke : DummyCallback;
                }

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

                /// <summary>
                /// Determines if the `callback` contains any method calls that will be serialized (otherwise the
                /// <see cref="DummyCallback"/> can be used instead of creating a new delegate to invoke the empty
                /// `callback`).
                /// </summary>
                public static bool HasPersistentCalls(SerializableCallback callback)
                {
                    if (callback == null)
                        return false;

                    // UnityEvents do not allow us to check if any dynamic calls are present.
                    // But we are not giving runtime access to the events so it does not really matter.
                    // UltEvents does allow it (via the HasCalls property), but we might as well be consistent.

#if ANIMANCER_ULT_EVENTS
                    var calls = callback.PersistentCallsList;
                    return calls != null && calls.Count > 0;
#else
                    return callback.GetPersistentEventCount() > 0;
#endif
                }

                /// <summary>
                /// Determines if the `callback` contains any method calls that will be serialized (otherwise the
                /// <see cref="DummyCallback"/> can be used instead of creating a new delegate to invoke the empty
                /// `callback`).
                /// <para></para>
                /// This method casts the `callback` to <see cref="SerializableCallback"/> so the caller does not need
                /// to know what type is actually being used.
                /// </summary>
                public static bool HasPersistentCalls(object callback)
                {
                    return HasPersistentCalls((SerializableCallback)callback);
                }

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

                /// <summary>
                /// Returns the <see cref="normalizedTime"/> of the <see cref="endEvent"/>.
                /// <para></para>
                /// If the value is not set, the value is determined by <see cref="GetDefaultNormalizedEndTime"/>.
                /// </summary>
                public float GetNormalizedEndTime(float speed = 0)
                {
                    if (_NormalizedTimes == null || _NormalizedTimes.Length == 0)
                        return GetDefaultNormalizedEndTime(speed);
                    else
                        return _NormalizedTimes[_NormalizedTimes.Length - 1];
                }

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

                /// <summary>Gets the internal details of the specified `serializable`.</summary>
                public static void GetDetails(Serializable serializable, out int timeCount, out int callbackCount)
                {
                    timeCount = serializable._NormalizedTimes != null ? serializable._NormalizedTimes.Length : 0;
                    callbackCount = serializable._Callbacks != null ? serializable._Callbacks.Length : 0;
                }

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

                /// <summary>[Editor-Only] Does nothing.</summary>
                void ISerializationCallbackReceiver.OnAfterDeserialize() { }

                /// <summary>[Editor-Only] Ensures that the events are sorted by time (excluding the end event).</summary>
                void ISerializationCallbackReceiver.OnBeforeSerialize()
                {
                    if (_NormalizedTimes == null ||
                        _NormalizedTimes.Length <= 2)
                        return;

                    var context = Editor.EventSequenceDrawer.Context.Instance;
                    var selectedEvent = context.Property != null ? context.SelectedEvent : -1;

                    var timeCount = _NormalizedTimes.Length - 1;
                    var callbackCount = _Callbacks != null ? _Callbacks.Length : 0;

                    var previousTime = _NormalizedTimes[0];

                    // Bubble Sort based on the normalized times.
                    var modifiedCallbacks = false;
                    for (int i = 1; i < timeCount; i++)
                    {
                        var time = _NormalizedTimes[i];
                        if (time >= previousTime)
                        {
                            previousTime = time;
                            continue;
                        }

                        time = _NormalizedTimes[i];
                        _NormalizedTimes[i] = _NormalizedTimes[i - 1];
                        _NormalizedTimes[i - 1] = time;

                        if (i == callbackCount)
                        {
                            Array.Resize(ref _Callbacks, ++callbackCount);
                        }

                        if (i < callbackCount)
                        {
                            var callback = _Callbacks[i];
                            _Callbacks[i] = _Callbacks[i - 1];
                            _Callbacks[i - 1] = callback;

                            modifiedCallbacks = true;
                        }

                        if (selectedEvent == i)
                            selectedEvent = i - 1;
                        else if (selectedEvent == i - 1)
                            selectedEvent = i;

                        if (i == 1)
                        {
                            i = 0;
                            previousTime = float.NegativeInfinity;
                        }
                        else
                        {
                            i -= 2;
                            previousTime = _NormalizedTimes[i];
                        }
                    }

                    if (context.Property != null && context.SelectedEvent != selectedEvent)
                    {
                        context.SelectedEvent = selectedEvent;
                        Editor.TransitionPreviewWindow.SetPreviewNormalizedTime(_NormalizedTimes[selectedEvent]);
                    }

                    if (modifiedCallbacks)
                    {
                        while (callbackCount >= 1)
                        {
                            var callback = _Callbacks[callbackCount - 1];
                            if (callback != null && HasPersistentCalls(callback))
                                break;
                            else
                                callbackCount--;
                        }

                        Array.Resize(ref _Callbacks, callbackCount);
                    }
                }

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

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

    namespace Editor
    {
        /// <summary>[Editor-Only] [Internal]
        /// A serializable container which holds a <see cref="SerializableCallback"/> in a field named "_Callback".
        /// </summary>
        /// <remarks>
        /// <see cref="DummySerializableCallback"/> needs to be in a file with the same name as it (otherwise it can't
        /// draw the callback properly) and this class needs to be in the same file as
        /// <see cref="AnimancerEvent.Sequence.Serializable"/> to use the <see cref="SerializableCallback"/> alias.
        /// </remarks>
        [Serializable]
        internal sealed class SerializableCallbackHolder
        {
#pragma warning disable CS0169 // Field is never used.
            [SerializeField]
            private SerializableCallback _Callback;
        }
    }

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