103 lines
4.3 KiB
C#
103 lines
4.3 KiB
C#
using System;
|
|
using UnityEngine;
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
namespace VLB
|
|
{
|
|
[Serializable]
|
|
public struct MinMaxRangeFloat : IEquatable<MinMaxRangeFloat>
|
|
{
|
|
public float minValue { get { return m_MinValue; } }
|
|
public float maxValue { get { return m_MaxValue; } }
|
|
|
|
public float randomValue { get { return UnityEngine.Random.Range(minValue, maxValue); } }
|
|
public Vector2 asVector2 { get { return new Vector2(minValue, maxValue); } }
|
|
|
|
public float GetLerpedValue(float lerp01) { return Mathf.Lerp(minValue, maxValue, lerp01); }
|
|
|
|
public MinMaxRangeFloat(float min, float max) { m_MinValue = min; m_MaxValue = max; Debug.Assert(min <= max); }
|
|
|
|
public override bool Equals(object obj) => obj is MinMaxRangeFloat other && this.Equals(other);
|
|
public bool Equals(MinMaxRangeFloat other) => (m_MinValue == other.m_MinValue) && (m_MaxValue == other.m_MaxValue);
|
|
public override int GetHashCode() => (m_MinValue, m_MaxValue).GetHashCode();
|
|
public static bool operator ==(MinMaxRangeFloat lhs, MinMaxRangeFloat rhs) => lhs.Equals(rhs);
|
|
public static bool operator !=(MinMaxRangeFloat lhs, MinMaxRangeFloat rhs) => !(lhs == rhs);
|
|
|
|
[SerializeField] float m_MinValue;
|
|
[SerializeField] float m_MaxValue;
|
|
}
|
|
|
|
public class MinMaxRangeAttribute : System.Attribute
|
|
{
|
|
public float minValue { get; private set; }
|
|
public float maxValue { get; private set; }
|
|
|
|
public MinMaxRangeAttribute(float min, float max) { minValue = min; maxValue = max; Debug.Assert(min <= max); }
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
[CustomPropertyDrawer(typeof(MinMaxRangeFloat), true)]
|
|
public class MinMaxRangeFloatPropertyDrawer : PropertyDrawer
|
|
{
|
|
static float RoundFloat(float f) { return (float)Math.Round(f * 100f) / 100f; }
|
|
|
|
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
|
|
{
|
|
label = EditorGUI.BeginProperty(position, label, property);
|
|
{
|
|
position = EditorGUI.PrefixLabel(position, label);
|
|
|
|
var propMin = property.FindPropertyRelative("m_MinValue");
|
|
Debug.AssertFormat(propMin != null, "Failed to find property 'MinMaxRangeFloat.m_MinValue'");
|
|
var propMax = property.FindPropertyRelative("m_MaxValue");
|
|
Debug.AssertFormat(propMax != null, "Failed to find property 'MinMaxRangeFloat.m_MaxValue'");
|
|
|
|
float valueMin = RoundFloat(propMin.floatValue);
|
|
float valueMax = RoundFloat(propMax.floatValue);
|
|
|
|
float rangeMin = 0.0f, rangeMax = 1.0f;
|
|
|
|
var ranges = (MinMaxRangeAttribute[])fieldInfo.GetCustomAttributes(typeof(MinMaxRangeAttribute), true);
|
|
if (ranges.Length > 0)
|
|
{
|
|
rangeMin = ranges[0].minValue;
|
|
rangeMax = ranges[0].maxValue;
|
|
}
|
|
|
|
const float kBoundsFieldWidth = 40.0f;
|
|
const float kWidthOffset = 5.0f;
|
|
|
|
EditorGUI.showMixedValue = propMin.hasMultipleDifferentValues || propMax.hasMultipleDifferentValues;
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
{
|
|
var rectMinValue = new Rect(position);
|
|
rectMinValue.width = kBoundsFieldWidth;
|
|
valueMin = EditorGUI.FloatField(rectMinValue, valueMin);
|
|
|
|
position.xMin += kBoundsFieldWidth + kWidthOffset;
|
|
|
|
var reactMaxValue = new Rect(position);
|
|
reactMaxValue.xMin = reactMaxValue.xMax - kBoundsFieldWidth;
|
|
valueMax = EditorGUI.FloatField(reactMaxValue, valueMax);
|
|
|
|
position.xMax -= kBoundsFieldWidth + kWidthOffset;
|
|
|
|
EditorGUI.MinMaxSlider(position, ref valueMin, ref valueMax, rangeMin, rangeMax);
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
propMin.floatValue = valueMin;
|
|
propMax.floatValue = valueMax;
|
|
}
|
|
}
|
|
EditorGUI.showMixedValue = false;
|
|
}
|
|
EditorGUI.EndProperty();
|
|
}
|
|
}
|
|
#endif
|
|
}
|