ECM2

2025-05-16 23:31:59 +08:00
parent 9e4fef3f1e
commit d891e3f0ee
1198 changed files with 274242 additions and 1558 deletions
--- a/Assets/VolumetricLightBeam/Scripts/MinMaxRangeFloat.cs
+++ b/Assets/VolumetricLightBeam/Scripts/MinMaxRangeFloat.cs
@@ -0,0 +1,102 @@
+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
+}