CrowdControl/Assets/Feel/MMFeedbacks/Editor/Sequencing/MMSequencerEditor.cs

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

namespace MoreMountains.Feedbacks
{
	/// <summary>
	/// Custom editor for MMSequencer, handles recalibration and sequencer display
	/// </summary>
	[CustomEditor(typeof(MMSequencer), true)]
	[CanEditMultipleObjects]
	public class MMSequencerEditor : Editor
	{
		protected MMSequencer _targetSequencer;
		protected float _inspectorWidth;
		protected GUIStyle _buttonStyle;
		protected GUIStyle _trackControlStyle;
		protected GUIStyle _indexStyle;
		protected Texture2D _buttonBackground;
		protected Texture2D _dotBackground;
		protected Color _buttonColor;
		protected Color _trackControlColor;

		protected Color _emptyButtonColor = new Color(0,0,0,0.5f);
		protected Color _empty4ButtonColor = new Color(0, 0, 0, 0.75f);
		protected const float _buttonWidth = 24;
		protected const float _trackControlWidth = 11;
		protected const float _distanceBetweenButtons = 6f;
		protected int _boxesPerLine;
		protected Color _originalBackgroundColor;
		protected Color _controlColor;

		protected List<float> _trackControlLastUseTimestamps;

		/// <summary>
		/// We want constant repaint on this inspector
		/// </summary>
		/// <returns></returns>
		public override bool RequiresConstantRepaint()
		{
			return true;
		}

		/// <summary>
		/// On enable we grab our textures and initialize our styles
		/// </summary>
		protected virtual void OnEnable()
		{
			_targetSequencer = (MMSequencer)target;
			_buttonBackground = Resources.Load("SequencerButtonBackground") as Texture2D;
			_dotBackground = Resources.Load("SequencerDotBackground") as Texture2D;
			_originalBackgroundColor = GUI.backgroundColor;

			_buttonStyle = new GUIStyle();
			_buttonStyle.normal.background = _buttonBackground;
			_buttonStyle.fixedWidth = _buttonWidth;
			_buttonStyle.fixedHeight = _buttonWidth;

			_trackControlStyle = new GUIStyle();
			_trackControlStyle.normal.background = _dotBackground;
			_trackControlStyle.normal.textColor = (Application.isPlaying) ? Color.black : Color.white;
			_trackControlStyle.fixedWidth = _trackControlWidth;
			_trackControlStyle.fixedHeight = _trackControlWidth;            
			_trackControlStyle.margin = new RectOffset(0, 0, 1, 0);
			_trackControlStyle.alignment = TextAnchor.MiddleCenter;
			_trackControlStyle.fontSize = 10;


			_indexStyle = new GUIStyle();
			_indexStyle.normal.background = _dotBackground;
			_indexStyle.normal.textColor = Color.white;
			_indexStyle.alignment = TextAnchor.MiddleCenter;
			_indexStyle.fixedWidth = _trackControlWidth * 1.5f;
			_indexStyle.fixedHeight = _trackControlWidth * 1.5f;

			FillControlList();
		}

		protected virtual void FillControlList()
		{
			// fill the control timer list
			if (_targetSequencer.Sequence != null)
			{
				_trackControlLastUseTimestamps = new List<float>();
				foreach (MMSequenceTrack track in _targetSequencer.Sequence.SequenceTracks)
				{
					_trackControlLastUseTimestamps.Add(0f);
				}
			}
		}

		/// <summary>
		/// Draws the default inspector and the sequencer
		/// </summary>
		public override void OnInspectorGUI()
		{
			serializedObject.Update();
			Undo.RecordObject(target, "Modified Sequence Recorder");

			DrawDefaultInspector();

			if (_targetSequencer.Sequence == null)
			{
				_targetSequencer.LastSequence = null;
				return;
			}

			// gets the width and computes how many boxes we can fit per line
			_inspectorWidth = EditorGUIUtility.currentViewWidth - 24;
			_boxesPerLine = (int)Mathf.Round(
				(_inspectorWidth - ((_targetSequencer.Sequence.SequenceTracks.Count) * _distanceBetweenButtons) - _trackControlWidth - _distanceBetweenButtons)
				/ (_buttonWidth + _distanceBetweenButtons)
			) + 1;

			LookForChanges();
            
			// separator
			EditorGUILayout.Space();
			EditorGUILayout.LabelField("Sequencer", EditorStyles.boldLabel);

			EditorGUILayout.BeginHorizontal();
			if (GUILayout.Button("Destroy and rebuild sequence", EditorStyles.miniButtonLeft))
			{
				_targetSequencer.Sequence.QuantizedSequence = null;
				_targetSequencer.LastTracksCount = -1;
				_targetSequencer.ApplySequencerLengthToSequence();
				EditorUtility.SetDirty(_targetSequencer.Sequence);
			}
			if (GUILayout.Button("Clear Sequence", EditorStyles.miniButtonMid))
			{
				_targetSequencer.ClearSequence();
				EditorUtility.SetDirty(_targetSequencer.Sequence);
			}
			if (GUILayout.Button("[ - ] Length - 1", EditorStyles.miniButtonMid))
			{
				_targetSequencer.DecrementLength();
				EditorUtility.SetDirty(_targetSequencer.Sequence);
			}
			if (GUILayout.Button("[ + ] Length + 1", EditorStyles.miniButtonRight))
			{
				_targetSequencer.IncrementLength();
				EditorUtility.SetDirty(_targetSequencer.Sequence);
			}
			EditorGUILayout.EndHorizontal();
            
			EditorGUILayout.Space();
			EditorGUILayout.Space();
			DrawSequenceIndexes();
			for (int i = 0; i < _targetSequencer.Sequence.SequenceTracks.Count; i++)
			{
				DrawTrack(i);
			}

			DrawControlButtons();

			serializedObject.ApplyModifiedProperties();
		}

		/// <summary>
		/// Whenever we detect a change in the settings we recalibrate our sequence accordingly
		/// </summary>
		protected virtual void LookForChanges()
		{
			if (_targetSequencer.LastSequence != _targetSequencer.Sequence)
			{
				FillControlList();
				if (_targetSequencer.Sequence.QuantizedSequence.Count > 0)
				{
					if (_targetSequencer.Sequence.QuantizedSequence[0].Line.Count != _targetSequencer.SequencerLength)
					{
						_targetSequencer.SequencerLength = _targetSequencer.Sequence.QuantizedSequence[0].Line.Count;
						_targetSequencer.LastSequencerLength = _targetSequencer.SequencerLength;
						_targetSequencer.LastSequence = _targetSequencer.Sequence;
						_targetSequencer.LastTracksCount = _targetSequencer.Sequence.SequenceTracks.Count;
					}
				}
				else
				{
					_targetSequencer.ApplySequencerLengthToSequence();
					_targetSequencer.LastSequence = _targetSequencer.Sequence;
					EditorUtility.SetDirty(_targetSequencer.Sequence);
				}                
			}   
            
			if (_targetSequencer.LastSequence == _targetSequencer.Sequence)
			{
				if (_targetSequencer.LastTracksCount != _targetSequencer.Sequence.SequenceTracks.Count)
				{
					FillControlList();
					_targetSequencer.ApplySequencerLengthToSequence();
					EditorUtility.SetDirty(_targetSequencer.Sequence);
				}
				if (_targetSequencer.LastBPM != _targetSequencer.BPM)
				{
					_targetSequencer.UpdateTimestampsToMatchNewBPM();
					EditorUtility.SetDirty(_targetSequencer.Sequence);
				}
			}

			_targetSequencer.EditorMaintenance();
		}

		/// <summary>
		/// Draws control buttons
		/// </summary>
		protected virtual void DrawControlButtons()
		{
			if (!Application.isPlaying)
			{
				return;
			}
			GUI.backgroundColor = _originalBackgroundColor;
			EditorGUILayout.Space();
			EditorGUILayout.LabelField("Controls", EditorStyles.boldLabel);

			if (_targetSequencer.Playing)
			{
				if (GUILayout.Button("Stop Playing"))
				{
					_targetSequencer.StopSequence();
				}
			}
			else
			{
				if (GUILayout.Button("Start Playing"))
				{
					_targetSequencer.PlaySequence();
				}
			}
			if (GUILayout.Button("Play Next Beat"))
			{
				_targetSequencer.PlayBeat();
			}
		}

		/// <summary>
		/// Draws an index for each sequence item
		/// </summary>
		protected virtual void DrawSequenceIndexes()
		{
			GUILayout.BeginHorizontal();

			GUI.backgroundColor = _emptyButtonColor;
			GUILayout.Label("", GUILayout.Width(_trackControlWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth));
			string label = "";
			for (int i = 0; i < _targetSequencer.SequencerLength; i++)
			{
				label = i < 10 ? " " + i.ToString() : i.ToString();
				_trackControlStyle.fontStyle = (i % 4 == 0) ? FontStyle.Bold : FontStyle.Normal;
				//GUILayout.Label(label, _indexStyle, GUILayout.Width(_buttonWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth));
				if (GUILayout.Button(label, _indexStyle, GUILayout.Width(_buttonWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth)))
				{
					_targetSequencer.ToggleStep(i);
					EditorUtility.SetDirty(_targetSequencer.Sequence);
				}
			}
			GUI.backgroundColor = _originalBackgroundColor;
			GUILayout.EndHorizontal();
			GUILayout.Space(_distanceBetweenButtons * 1.5f);
		}

		/// <summary>
		/// Draws a line of the sequencer
		/// </summary>
		/// <param name="trackIndex"></param>
		protected virtual void DrawTrack(int trackIndex)
		{
			int counter = 0;

			if (_targetSequencer.Sequence.QuantizedSequence == null)
			{
				return;
			}

			if (_targetSequencer.Sequence.QuantizedSequence.Count != _targetSequencer.Sequence.SequenceTracks.Count)
			{
				return;
			}

			GUILayout.BeginHorizontal();


			GUILayout.BeginVertical();

			// draw active track control

			if (_targetSequencer.Sequence.SequenceTracks[trackIndex].Active)
			{
				_trackControlColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
			}
			else
			{
				_trackControlColor = _emptyButtonColor;
			}

			GUI.backgroundColor = _trackControlColor;
			if (GUILayout.Button("", _trackControlStyle, GUILayout.Width(_trackControlWidth), GUILayout.Height(_trackControlWidth)))
			{
				if (_targetSequencer.TrackEvents[trackIndex] != null)
				{
					_targetSequencer.ToggleActive(trackIndex);
					EditorUtility.SetDirty(_targetSequencer.Sequence);
				}
			}

			GUILayout.Space(_distanceBetweenButtons / 5);

			// draw test track control
			_trackControlColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
			_controlColor = Application.isPlaying ? SequencerColor(_trackControlLastUseTimestamps[trackIndex], _trackControlColor) : Color.black;
			GUI.backgroundColor = _controlColor;
			if (GUILayout.Button(trackIndex.ToString(), _trackControlStyle, GUILayout.Width(_trackControlWidth), GUILayout.Height(_trackControlWidth)))
			{
				if (_targetSequencer.TrackEvents[trackIndex] != null)
				{
					_trackControlLastUseTimestamps[trackIndex] = Time.time;
					_targetSequencer.PlayTrackEvent(trackIndex);
				}
			}
			GUILayout.EndVertical();

			GUILayout.Space(_distanceBetweenButtons);

			for (int i = 0; i < _targetSequencer.Sequence.QuantizedSequence[trackIndex].Line.Count; i++)
			{
				// handle new lines
				if (counter > _boxesPerLine )
				{
					GUILayout.EndHorizontal();
					GUILayout.Space(_distanceBetweenButtons);
					GUILayout.BeginHorizontal();
					counter = 0;
				}

				if (_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[i].ID != -1)
				{
					_buttonColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
				}
				else
				{
					if (i % 4 == 0)
					{
						_buttonColor = _empty4ButtonColor;
					}
					else
					{
						_buttonColor = _emptyButtonColor;
					}
				}
				// if the track is inactive, we reduce colors
				if (!_targetSequencer.Sequence.SequenceTracks[trackIndex].Active)
				{
					_buttonColor = _buttonColor / 2f;
				}

				DrawSequenceButton(trackIndex, i, _buttonColor);
                
				counter++;
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.Space(_distanceBetweenButtons);
		}

		/// <summary>
		/// Draws an interactive button for the sequencer
		/// </summary>
		/// <param name="trackIndex"></param>
		/// <param name="sequenceIndex"></param>
		/// <param name="buttonColor"></param>
		protected virtual void DrawSequenceButton(int trackIndex, int sequenceIndex, Color buttonColor)
		{

			if (Application.isPlaying && _targetSequencer.PlayedOnce && (_targetSequencer.LastBeatIndex == sequenceIndex))
			{
				if (_targetSequencer.BeatThisFrame)
				{
					_buttonColor = Color.white;
				}
				else
				{
					_buttonColor = SequencerColor(_targetSequencer.LastBeatTimestamp, buttonColor);
				}
			}
			else
			{
				_buttonColor = buttonColor;
			}

			GUI.backgroundColor = _buttonColor;
			if (GUILayout.Button("", _buttonStyle, GUILayout.Width(_buttonWidth), GUILayout.Height(_buttonWidth)))
			{
				bool active = (_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[sequenceIndex].ID == _targetSequencer.Sequence.SequenceTracks[trackIndex].ID);
				_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[sequenceIndex].ID = active ? -1 : _targetSequencer.Sequence.SequenceTracks[trackIndex].ID;
				EditorUtility.SetDirty(_targetSequencer.Sequence);
			}
			GUILayout.Space(_distanceBetweenButtons);
		}

		/// <summary>
		/// Color interpolation on hits
		/// </summary>
		/// <param name="lastBeatTimestamp"></param>
		/// <param name="buttonColor"></param>
		/// <returns></returns>
		protected virtual Color SequencerColor(float lastBeatTimestamp, Color buttonColor)
		{
			float x = (Time.time - lastBeatTimestamp);
			float A = 0f;
			float B = (60f / _targetSequencer.BPM) / 4f;
			float C = 0f;
			float D = 1f;
			float t = C + (x - A) / (B - A) * (D - C);
			return Color.Lerp(Color.white, buttonColor, t);
		}
	}
}