Add DoubleRange

Author: adamgraham

Editor/Structs/DoubleRangePropertyDrawer.cs

@@ -0,0 +1,45 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Zigurous.Architecture.Editor
+{
+    [CustomPropertyDrawer(typeof(DoubleRange))]
+    public class DoubleRangePropertyDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+
+            position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
+
+            int indentLevel = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
+            position = DoubleField(position, property.FindPropertyRelative("m_Min"));
+            position = DoubleField(position, property.FindPropertyRelative("m_Max"));
+
+            EditorGUI.indentLevel = indentLevel;
+            EditorGUI.EndProperty();
+        }
+
+        private Rect DoubleField(Rect position, SerializedProperty property)
+        {
+            Rect field = EditorGUIUtility.GetFieldRect(position, 2);
+            position.x += field.width + EditorGUIUtility.standardHorizontalSpacing;
+
+            EditorGUI.BeginChangeCheck();
+
+            double value = EditorGUIUtility.FieldWrapper(property.displayName, (label) => {
+                return EditorGUI.DoubleField(field, label, property.doubleValue);
+            });
+
+            if (EditorGUI.EndChangeCheck()) {
+                property.doubleValue = value;
+            }
+
+            return position;
+        }
+
+    }
+
+}

Editor/Structs/DoubleRangePropertyDrawer.cs.meta

@@ -0,0 +1,145 @@
+using UnityEngine;
+
+namespace Zigurous.Architecture
+{
+    /// <summary>
+    /// A range of double values.
+    /// </summary>
+    [System.Serializable]
+    public struct DoubleRange
+    {
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(0.0, 0.0)</c>.
+        /// </summary>
+        public static DoubleRange zero => new DoubleRange(0.0, 0.0);
+
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(1.0, 1.0)</c>.
+        /// </summary>
+        public static DoubleRange one => new DoubleRange(1.0, 1.0);
+
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(0.0, 1.0)</c>.
+        /// </summary>
+        public static DoubleRange percent => new DoubleRange(0.0, 1.0);
+
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(0.0, double.MaxValue)</c>.
+        /// </summary>
+        public static DoubleRange positive => new DoubleRange(0.0, double.MaxValue);
+
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(double.MinValue, 0.0)</c>.
+        /// </summary>
+        public static DoubleRange negative => new DoubleRange(double.MinValue, 0.0);
+
+        /// <summary>
+        /// Shorthand for writing <c>DoubleRange(double.MinValue, double.MaxValue)</c>.
+        /// </summary>
+        public static DoubleRange minMax => new DoubleRange(double.MinValue, double.MaxValue);
+
+        [SerializeField]
+        [Tooltip("The lower bound of the range.")]
+        private double m_Min;
+
+        [SerializeField]
+        [Tooltip("The upper bound of the range.")]
+        private double m_Max;
+
+        /// <summary>
+        /// The lower bound of the range.
+        /// </summary>
+        public double min
+        {
+            get => m_Min;
+            set => m_Min = value;
+        }
+
+        /// <summary>
+        /// The upper bound of the range.
+        /// </summary>
+        public double max
+        {
+            get => m_Max;
+            set => m_Max = value;
+        }
+
+        /// <summary>
+        /// The difference between the maximum and minimum values (Read only).
+        /// </summary>
+        public double delta => max - min;
+
+        /// <summary>
+        /// The median value of the range (Read only).
+        /// </summary>
+        public double median => (min + max) / 2.0;
+
+        /// <summary>
+        /// Creates a new range with the specified values.
+        /// </summary>
+        /// <param name="min">The lower bound of the range.</param>
+        /// <param name="max">The upper bound of the range.</param>
+        public DoubleRange(double min = 0.0, double max = 1.0)
+        {
+            m_Min = min;
+            m_Max = max;
+        }
+
+        /// <summary>
+        /// Checks if a value is in the range.
+        /// </summary>
+        /// <param name="value">The value to check.</param>
+        /// <returns>True if the value is in the range, false otherwise.</returns>
+        public bool Includes(double value)
+        {
+            return value >= min && value <= max;
+        }
+
+        /// <summary>
+        /// Checks if a value is in the range.
+        /// </summary>
+        /// <param name="value">The value to check.</param>
+        /// <param name="includeMin">The minimum value is inclusive if true, exclusive if false.</param>
+        /// <param name="includeMax">The maximum value is inclusive if true, exclusive if false.</param>
+        /// <returns>True if the value is in the range, false otherwise.</returns>
+        public bool Includes(double value, bool includeMin, bool includeMax)
+        {
+            return value.IsBetween(min, max, includeMin, includeMax);
+        }
+
+        /// <summary>
+        /// Clamps a value to the range.
+        /// </summary>
+        /// <param name="value">The value to clamp.</param>
+        /// <returns>The clamped value.</returns>
+        public double Clamp(double value)
+        {
+            return value < min ? min : (value > max ? max : value);
+        }
+
+        /// <summary>
+        /// Linearly interpolates between the range by <paramref name="t"/>.
+        /// </summary>
+        /// <param name="t">The interpolant value between [0..1].</param>
+        /// <returns>The interpolated value.</returns>
+        public double Lerp(double t)
+        {
+            t = t < 0.0 ? 0.0 : (t > 1.0 ? 1.0 : t);
+            return min + (max - min) * t;
+        }
+
+        /// <summary>
+        /// Calculates the linear parameter t that produces the interpolant
+        /// value within the range.
+        /// </summary>
+        /// <param name="value">The value within the range you want to calculate.</param>
+        /// <returns>The interpolant value between [0..1].</returns>
+        public double InverseLerp(double value)
+        {
+            double t = (value - min) / (max - min);
+            return t < 0.0 ? 0.0 : (t > 1.0 ? 1.0 : t);
+        }
+
+    }
+
+}

Runtime/DataStructures/Ranges/DoubleRange.cs

@@ -17,7 +17,8 @@ public static class ComparableExtensions
         /// <param name="includeMin">The minimum value is inclusive if true, exclusive if false.</param>
         /// <param name="includeMax">The maximum value is inclusive if true, exclusive if false.</param>
         /// <returns>True if the value is between the min and max.</returns>
-        public static bool IsBetween<T>(this T value, T min, T max, bool includeMin, bool includeMax) where T : IComparable<T>
+        public static bool IsBetween<T>(this T value, T min, T max, bool includeMin, bool includeMax)
+            where T : IComparable<T>
         {
             int minCompare = value.CompareTo(min);
             int maxCompare = value.CompareTo(max);