Add new TimingRange01 data structure

Author: adamgraham

.docfx/manual/index.md

@@ -21,6 +21,7 @@ The **Animation Library** package contains assets and scripts for animating Unit
 - [Timing](xref:Zigurous.Animation.Timing)
 - [Timing01](xref:Zigurous.Animation.Timing01)
 - [TimingRange](xref:Zigurous.Animation.TimingRange)
+- [TimingRange01](xref:Zigurous.Animation.TimingRange01)
 - [Vector2AnimationCurve](xref:Zigurous.Animation.Vector2AnimationCurve)
 - [Vector3AnimationCurve](xref:Zigurous.Animation.Vector3AnimationCurve)
 - [Vector4AnimationCurve](xref:Zigurous.Animation.Vector4AnimationCurve)

Editor/TimingRange01PropertyDrawer.cs

@@ -0,0 +1,73 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Zigurous.Animation.Editor
+{
+    [CustomPropertyDrawer(typeof(TimingRange01))]
+    public sealed class TimingRange01PropertyDrawer : PropertyDrawer
+    {
+        private const float horizontalSpacing = 4.0f;
+
+        private SerializedProperty _min;
+        private SerializedProperty _max;
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            // Start drawing the property
+            EditorGUI.BeginProperty(position, label, property);
+
+            // Draw the property label
+            position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
+
+            // Store orginal sizes so they can be set back to their original values
+            int originalIndent = EditorGUI.indentLevel;
+            float originalLabelWidth = EditorGUIUtility.labelWidth;
+
+            // Set indent level of child fields
+            EditorGUI.indentLevel = 0;
+
+            // Create references to child fields
+            if (_min == null) _min = property.FindPropertyRelative("_min");
+            if (_max == null) _max = property.FindPropertyRelative("_max");
+
+            // Calculate the bounds of the child fields
+            Rect rect = new Rect(position);
+            rect.width = (position.width - horizontalSpacing) / 2;
+
+            // Draw the child fields
+            rect = SliderWithChangeCheck(_min, rect, "Min");
+            rect = SliderWithChangeCheck(_max, rect, "Max");
+
+            // Set sizes back to their original values
+            EditorGUI.indentLevel = originalIndent;
+            EditorGUIUtility.labelWidth = originalLabelWidth;
+
+            // Finish drawing the property
+            EditorGUI.EndProperty();
+        }
+
+        private Rect SliderWithChangeCheck(SerializedProperty property, Rect position, string displayName)
+        {
+            // Check for changes in the field's value
+            EditorGUI.BeginChangeCheck();
+
+            // Calculate the width of the field label
+            GUIContent label = new GUIContent(displayName);
+            EditorGUIUtility.labelWidth = EditorStyles.label.CalcSize(label).x;
+
+            // Draw the field and store the field's value
+            float value = EditorGUI.Slider(position, label, property.floatValue, 0.0f, 1.0f);
+
+            // Update the property's value from the field
+            if (EditorGUI.EndChangeCheck()) {
+                property.floatValue = value;
+            }
+
+            // Advance the position for the next child field
+            position.x += position.width + horizontalSpacing;
+            return position;
+        }
+
+    }
+
+}

Editor/TimingRange01PropertyDrawer.cs.meta

@@ -6,7 +6,7 @@ namespace Zigurous.Animation.Editor
     [CustomPropertyDrawer(typeof(TimingRange))]
     public sealed class TimingRangePropertyDrawer : PropertyDrawer
     {
-        private static readonly float horizontalSpacing = 4.0f;
+        private const float horizontalSpacing = 4.0f;
 
         private SerializedProperty _min;
         private SerializedProperty _max;

Editor/TimingRangePropertyDrawer.cs

@@ -3,61 +3,45 @@
 namespace Zigurous.Animation
 {
     /// <summary>
-    /// Represents an animation timing range normalized between 0 and 1.
+    /// Represents an animation timing range between a lower and upper bound.
     /// </summary>
     [System.Serializable]
     public struct TimingRange
     {
-        [SerializeField]
-        [Tooltip("The start time of the animation, between 0 and 1.")]
-        [Range(0.0f, 1.0f)]
-        private float _start;
-
         /// <summary>
-        /// The start time of the animation, between 0 and 1.
+        /// The lower bound of the timing range.
         /// </summary>
-        public float start
-        {
-            get => _start;
-            set => _start = Mathf.Clamp01(value);
-        }
-
-        [SerializeField]
-        [Tooltip("The end time of the animation, between 0 and 1.")]
-        [Range(0.0f, 1.0f)]
-        private float _end;
+        [Tooltip("The lower bound of the timing range.")]
+        public float min;
 
         /// <summary>
-        /// The end time of the animation, between 0 and 1.
+        /// The upper bound of the timing range.
         /// </summary>
-        public float end
-        {
-            get => _end;
-            set => _end = Mathf.Clamp01(value);
-        }
+        [Tooltip("The upper bound of the timing range.")]
+        public float max;
 
-        /// <summary>Constructs a new TimingRange with the given <paramref name="start"/> and <paramref name="end"/>.</summary>
-        /// <param name="start">The start time of the animation, between 0 and 1.</param>
-        /// <param name="end">The end time of the animation, between 0 and 1.</param>
-        public TimingRange(float start, float end)
+        /// <summary>Constructs a new timing range with the given <paramref name="min"/> and <paramref name="max"/>.</summary>
+        /// <param name="min">The lower bound of the timing range.</param>
+        /// <param name="max">The upper bound of the timing range.</param>
+        public TimingRange(float min, float max)
         {
-            _start = Mathf.Clamp01(start);
-            _end = Mathf.Clamp01(end);
+            this.min = min;
+            this.max = max;
         }
 
         /// <returns>
-        /// A random time within the start and end time.
+        /// A random time within the min and max time.
         /// </returns>
         public float Random()
         {
-            return UnityEngine.Random.Range(this.start, this.end);
+            return UnityEngine.Random.Range(this.min, this.max);
         }
 
-        /// <returns>Whether the given <paramref name="time"/> is within range of the animation timing.</returns>
+        /// <returns>Whether the given <paramref name="time"/> is within the min and max time.</returns>
         /// <param name="time">The time to check.</param>
         public bool Includes(float time)
         {
-            return time >= this.start && time <= this.end;
+            return time >= this.min && time <= this.max;
         }
 
     }

Runtime/DataStructures/TimingRange.cs

@@ -0,0 +1,66 @@
+using UnityEngine;
+
+namespace Zigurous.Animation
+{
+    /// <summary>
+    /// Represents an animation timing range between a lower and upper bound
+    /// normalized between 0 and 1.
+    /// </summary>
+    [System.Serializable]
+    public struct TimingRange01
+    {
+        [SerializeField]
+        [Tooltip("The lower bound of the timing range, between 0 and 1.")]
+        [Range(0.0f, 1.0f)]
+        private float _min;
+
+        /// <summary>
+        /// The lower bound of the timing range, between 0 and 1.
+        /// </summary>
+        public float min
+        {
+            get => _min;
+            set => _min = Mathf.Clamp01(value);
+        }
+
+        [SerializeField]
+        [Tooltip("The upper bound of the timing range, between 0 and 1.")]
+        [Range(0.0f, 1.0f)]
+        private float _max;
+
+        /// <summary>
+        /// The upper bound of the timing range, between 0 and 1.
+        /// </summary>
+        public float max
+        {
+            get => _max;
+            set => _max = Mathf.Clamp01(value);
+        }
+
+        /// <summary>Constructs a new timing range with the given <paramref name="min"/> and <paramref name="max"/>.</summary>
+        /// <param name="min">The lower bound of the timing range, between 0 and 1.</param>
+        /// <param name="max">The upper bound of the timing range, between 0 and 1.</param>
+        public TimingRange01(float min, float max)
+        {
+            _min = Mathf.Clamp01(min);
+            _max = Mathf.Clamp01(max);
+        }
+
+        /// <returns>
+        /// A random time within the min and max time.
+        /// </returns>
+        public float Random()
+        {
+            return UnityEngine.Random.Range(this.min, this.max);
+        }
+
+        /// <returns>Whether the given <paramref name="time"/> is within the min and max time.</returns>
+        /// <param name="time">The time to check.</param>
+        public bool Includes(float time)
+        {
+            return time >= this.min && time <= this.max;
+        }
+
+    }
+
+}