ConditionalMemberEvaluator.cs

#if UNITY_EDITOR
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using UnityEditor;
using UnityEngine;
 
#pragma warning disable IDE0130
namespace SCG.Editor
#pragma warning restore IDE0130
{
    internal static class ConditionalMemberEvaluator
    {
        #region Constants
 
        private static readonly FieldInfo customPropertyDrawerTypeField =
            typeof(CustomPropertyDrawer).GetField("m_Type", BindingFlags.Instance | BindingFlags.NonPublic);
 
        private static readonly FieldInfo customPropertyDrawerUseForChildrenField =
            typeof(CustomPropertyDrawer).GetField("m_UseForChildren", BindingFlags.Instance | BindingFlags.NonPublic);
 
        private static readonly FieldInfo propertyDrawerFieldInfoField =
            typeof(PropertyDrawer).GetField("m_FieldInfo", BindingFlags.Instance | BindingFlags.NonPublic);
 
        private static readonly BuiltInDrawerRegistration[] builtInDrawerRegistrations = BuildBuiltInDrawerRegistrations();
 
        private static readonly Type[] builtInDrawerConflictTypes = builtInDrawerRegistrations
            .Select(registration => registration.TargetType)
            .Distinct()
            .ToArray();
 
        private static readonly Dictionary<string, PropertyDrawer> builtInDrawerCache = new();
        private static readonly Dictionary<Type, MethodInfo> builtInDrawerOnGuiMethodCache = new();
        private static readonly Dictionary<Type, MethodInfo> builtInDrawerGetPropertyHeightMethodCache = new();
 
        private static readonly Type[] onGuiParameterTypes =
        {
            typeof(Rect),
            typeof(SerializedProperty),
            typeof(GUIContent)
        };
 
        private static readonly Type[] getPropertyHeightParameterTypes =
        {
            typeof(SerializedProperty),
            typeof(GUIContent)
        };
 
        #endregion

        internal static bool ShouldShow(SerializedProperty property, ShowIfAttribute attribute) =>
            attribute == null || property == null ||
            !TryEvaluate(property, attribute.MemberName, Array.Empty<object>(), out var conditionMet) ||
            (attribute.Invert
                ? !conditionMet
                : conditionMet);

        internal static bool ShouldEnable(SerializedProperty property, EnableIfAttribute attribute) =>
            attribute == null || property == null ||
            !TryEvaluate(property, attribute.MemberName, attribute.ExpectedValues, out var conditionMet) ||
            conditionMet;

        internal static bool TryGetBuiltInDrawer(SerializedProperty property, FieldInfo fieldInfo, out PropertyDrawer drawer)
        {
            drawer = null;
            if (property == null || fieldInfo == null || !RequiresBuiltInDrawerDelegation(fieldInfo.FieldType) ||
                !TryGetBuiltInDrawerRegistration(fieldInfo.FieldType, out var registration))
                return false;
 
            var cacheKey = GetBuiltInDrawerCacheKey(property, registration.DrawerType);
            if (!string.IsNullOrEmpty(cacheKey) && builtInDrawerCache.TryGetValue(cacheKey, out drawer))
                return drawer != null;
 
            drawer = CreateBuiltInDrawer(fieldInfo, registration);
            if (drawer == null)
                return false;
 
            if (!string.IsNullOrEmpty(cacheKey))
                builtInDrawerCache[cacheKey] = drawer;
 
            return true;
        }

        internal static void DrawBuiltInDrawer(PropertyDrawer drawer, Rect position, SerializedProperty property, GUIContent label)
        {
            if (drawer == null)
                return;
 
            var method = GetDrawerMethod(drawer.GetType(), nameof(PropertyDrawer.OnGUI), builtInDrawerOnGuiMethodCache, onGuiParameterTypes);
            method?.Invoke(drawer, new object[] { position, property, label });
        }

        internal static float GetBuiltInDrawerHeight(PropertyDrawer drawer, SerializedProperty property, GUIContent label)
        {
            if (drawer == null)
                return EditorGUI.GetPropertyHeight(property, label, true);
 
            var method = GetDrawerMethod(
                drawer.GetType(),
                nameof(PropertyDrawer.GetPropertyHeight),
                builtInDrawerGetPropertyHeightMethodCache,
                getPropertyHeightParameterTypes);
            return method?.Invoke(drawer, new object[] { property, label }) is float height
                ? height
                : EditorGUI.GetPropertyHeight(property, label, true);
        }
 
        #region Evaluation
 
        private static bool TryEvaluate(
            SerializedProperty property,
            string memberName,
            object[] expectedValues,
            out bool conditionMet)
        {
            conditionMet = false;
            if (property == null || string.IsNullOrEmpty(memberName))
                return false;
 
            if (!TryGetConditionValue(property, memberName, out var conditionValue))
                return false;
 
            conditionMet = MatchesExpectedValues(conditionValue, expectedValues);
            return true;
        }
 
        private static bool TryGetConditionValue(SerializedProperty property, string memberName, out object value) =>
            TryGetConditionFromSerializedProperty(property, memberName, out value) ||
            TryGetConditionFromMember(GetTargetObjectOfProperty(property, false), memberName, out value);
 
        private static bool MatchesExpectedValues(object conditionValue, object[] expectedValues) =>
            expectedValues == null || expectedValues.Length == 0
                ? conditionValue is true
                : expectedValues.Any(expectedValue => AreEqual(conditionValue, expectedValue));
 
        private static bool AreEqual(object left, object right)
        {
            if (ReferenceEquals(left, right))
                return true;
 
            if (left == null || right == null)
                return false;
 
            if (left.Equals(right))
                return true;
 
            var leftText = left.ToString();
            var rightText = right.ToString();
            if (string.Equals(leftText, rightText, StringComparison.Ordinal))
                return true;
 
            try
            {
                var convertedRight = Convert.ChangeType(right, left.GetType());
                return left.Equals(convertedRight);
            }
            catch
            {
                return false;
            }
        }
 
        #endregion
 
        #region Built-In Drawers
 
        #region Nested
 
        private sealed class BuiltInDrawerRegistration
        {
            public Type TargetType { get; }
            public Type DrawerType { get; }
            public bool UseForChildren { get; }
 
            public BuiltInDrawerRegistration(Type targetType, Type drawerType, bool useForChildren)
            {
                TargetType = targetType;
                DrawerType = drawerType;
                UseForChildren = useForChildren;
            }
        }
 
        #endregion
 
        private static BuiltInDrawerRegistration[] BuildBuiltInDrawerRegistrations() => AppDomain.CurrentDomain
            .GetAssemblies()
            .Where(IsUnityAssembly)
            .SelectMany(GetTypesSafely)
            .Where(type => typeof(PropertyDrawer).IsAssignableFrom(type) && !type.IsAbstract)
            .SelectMany(GetBuiltInDrawerRegistrations)
            .GroupBy(registration => $"{registration.TargetType.AssemblyQualifiedName}|{registration.DrawerType.AssemblyQualifiedName}|{registration.UseForChildren}")
            .Select(group => group.First())
            .ToArray();
 
        private static IEnumerable<Type> GetTypesSafely(Assembly assembly)
        {
            if (assembly == null)
                return Array.Empty<Type>();
 
            try
            {
                return assembly.GetTypes();
            }
            catch (ReflectionTypeLoadException exception)
            {
                return exception.Types.Where(type => type != null);
            }
            catch
            {
                return Array.Empty<Type>();
            }
        }
 
        private static IEnumerable<BuiltInDrawerRegistration> GetBuiltInDrawerRegistrations(Type drawerType)
        {
            if (drawerType == null || customPropertyDrawerTypeField == null || customPropertyDrawerUseForChildrenField == null)
                yield break;
 
            var attributes = drawerType.GetCustomAttributes(typeof(CustomPropertyDrawer), false);
            foreach (var attribute in attributes)
            {
                var targetType = customPropertyDrawerTypeField.GetValue(attribute) as Type;
                if (targetType == null || typeof(PropertyAttribute).IsAssignableFrom(targetType))
                    continue;
 
                yield return new BuiltInDrawerRegistration(
                    targetType,
                    drawerType,
                    customPropertyDrawerUseForChildrenField.GetValue(attribute) is true);
            }
        }
 
        private static bool TryGetBuiltInDrawerRegistration(Type fieldType, out BuiltInDrawerRegistration registration)
        {
            registration = null;
            if (fieldType == null)
                return false;
 
            registration = builtInDrawerRegistrations.FirstOrDefault(entry => IsExactDrawerTarget(entry.TargetType, fieldType));
            if (registration != null)
                return true;
 
            registration = builtInDrawerRegistrations
                .Where(entry => entry.UseForChildren && MatchesDrawerTarget(entry.TargetType, fieldType))
                .OrderByDescending(entry => GetSpecificity(entry.TargetType))
                .FirstOrDefault();
            return registration != null;
        }
 
        private static bool RequiresBuiltInDrawerDelegation(Type fieldType) =>
            fieldType != null &&
            builtInDrawerConflictTypes.Any(conflictType => IsExactDrawerTarget(conflictType, fieldType) || conflictType.IsAssignableFrom(fieldType));
 
        private static bool IsExactDrawerTarget(Type targetType, Type fieldType) =>
            targetType == fieldType ||
            (targetType.IsGenericTypeDefinition &&
             fieldType.IsGenericType &&
             fieldType.GetGenericTypeDefinition() == targetType);
 
        private static bool MatchesDrawerTarget(Type targetType, Type fieldType) =>
            !targetType.IsGenericTypeDefinition &&
            targetType.IsAssignableFrom(fieldType);
 
        private static int GetSpecificity(Type type)
        {
            var depth = 0;
            while (type != null)
            {
                depth++;
                type = type.BaseType;
            }
 
            return depth;
        }
 
        private static bool IsUnityAssembly(Assembly assembly)
        {
            var assemblyName = assembly?.GetName().Name;
            return !string.IsNullOrEmpty(assemblyName) &&
                   assemblyName.StartsWith(nameof(Unity), StringComparison.Ordinal);
        }
 
        private static PropertyDrawer CreateBuiltInDrawer(FieldInfo fieldInfo, BuiltInDrawerRegistration registration)
        {
            if (fieldInfo == null || registration?.DrawerType == null)
                return null;
 
            try
            {
                if (Activator.CreateInstance(registration.DrawerType, true) is not PropertyDrawer drawer)
                    return null;
 
                propertyDrawerFieldInfoField?.SetValue(drawer, fieldInfo);
                return drawer;
            }
            catch
            {
                return null;
            }
        }
 
        private static MethodInfo GetDrawerMethod(
            Type drawerType,
            string methodName,
            Dictionary<Type, MethodInfo> cache,
            Type[] parameterTypes)
        {
            if (drawerType == null || string.IsNullOrEmpty(methodName) || cache == null || parameterTypes == null)
                return null;
 
            if (cache.TryGetValue(drawerType, out var method))
                return method;
 
            method = drawerType.GetMethod(
                methodName,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                null,
                parameterTypes,
                null);
            cache[drawerType] = method;
            return method;
        }
 
        private static string GetBuiltInDrawerCacheKey(SerializedProperty property, Type drawerType)
        {
            if (property == null || drawerType == null)
                return null;
 
            var targetObject = property.serializedObject?.targetObject;
            var targetId = targetObject != null
                ? RuntimeHelpers.GetHashCode(targetObject)
                : 0;
            return $"{drawerType.AssemblyQualifiedName}|{targetId}|{property.propertyPath}";
        }
 
        #endregion
 
        #region SerializedProperty
 
        private static bool TryGetConditionFromSerializedProperty(SerializedProperty property, string memberName, out object value)
        {
            value = null;
            if (property == null)
                return false;
 
            var conditionProperty = FindSiblingProperty(property, memberName);
            return conditionProperty != null && TryGetSerializedPropertyValue(conditionProperty, out value);
        }
 
        private static bool TryGetSerializedPropertyValue(SerializedProperty property, out object value)
        {
            value = null;
            if (property == null)
                return false;
 
            switch (property.propertyType)
            {
                case SerializedPropertyType.Boolean:
                    value = property.boolValue;
                    return true;
                case SerializedPropertyType.Integer:
                    value = property.intValue;
                    return true;
                case SerializedPropertyType.Float:
                    value = property.floatValue;
                    return true;
                case SerializedPropertyType.String:
                    value = property.stringValue;
                    return true;
                case SerializedPropertyType.Enum:
                    value = property.enumValueIndex >= 0 && property.enumValueIndex < property.enumNames.Length
                        ? property.enumNames[property.enumValueIndex]
                        : property.enumValueIndex;
                    return true;
                case SerializedPropertyType.Generic:
                case SerializedPropertyType.Color:
                case SerializedPropertyType.ObjectReference:
                case SerializedPropertyType.LayerMask:
                case SerializedPropertyType.Vector2:
                case SerializedPropertyType.Vector3:
                case SerializedPropertyType.Vector4:
                case SerializedPropertyType.Rect:
                case SerializedPropertyType.ArraySize:
                case SerializedPropertyType.Character:
                case SerializedPropertyType.AnimationCurve:
                case SerializedPropertyType.Bounds:
                case SerializedPropertyType.Gradient:
                case SerializedPropertyType.Quaternion:
                case SerializedPropertyType.ExposedReference:
                case SerializedPropertyType.FixedBufferSize:
                case SerializedPropertyType.Vector2Int:
                case SerializedPropertyType.Vector3Int:
                case SerializedPropertyType.RectInt:
                case SerializedPropertyType.BoundsInt:
                case SerializedPropertyType.ManagedReference:
                case SerializedPropertyType.Hash128:
                default:
                    return false;
            }
        }
 
        private static SerializedProperty FindSiblingProperty(SerializedProperty property, string name)
        {
            var path = property.propertyPath;
            if (string.IsNullOrEmpty(path))
                return null;
 
            var lastDot = path.LastIndexOf('.');
            var parentPath = lastDot >= 0
                ? path[..(lastDot + 1)]
                : string.Empty;
            return property.serializedObject.FindProperty(parentPath + name);
        }
 
        #endregion
 
        #region Reflection
 
        private static bool TryGetConditionFromMember(object target, string memberName, out object value)
        {
            value = null;
            if (target == null || string.IsNullOrEmpty(memberName))
                return false;
 
            const BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            var type = target.GetType();
            while (type != null)
            {
                var field = type.GetField(memberName, flags);
                if (field != null)
                {
                    value = field.GetValue(target);
                    return true;
                }
 
                var property = type.GetProperty(memberName, flags);
                if (property != null && property.GetIndexParameters().Length == 0)
                {
                    value = property.GetValue(target, null);
                    return true;
                }
 
                var method = type.GetMethod(memberName, flags, null, Type.EmptyTypes, null);
                if (method != null)
                {
                    value = method.Invoke(target, null);
                    return true;
                }
 
                type = type.BaseType;
            }
 
            return false;
        }
 
        private static object GetTargetObjectOfProperty(SerializedProperty property, bool includeSelf)
        {
            if (property?.serializedObject?.targetObject is not object target)
                return null;
 
            var path = property.propertyPath.Replace(".Array.data[", "[");
            var elements = path.Split('.');
            var endIndex = includeSelf
                ? elements.Length
                : Math.Max(0, elements.Length - 1);
 
            for (var i = 0; i < endIndex; i++)
            {
                var element = elements[i];
                if (element.EndsWith("]"))
                {
                    var bracketIndex = element.IndexOf('[');
                    var fieldName = element[..bracketIndex];
                    var indexText = element.Substring(bracketIndex + 1, element.Length - bracketIndex - 2);
                    if (!int.TryParse(indexText, out var index))
                        return null;
 
                    target = GetIndexedValue(target, fieldName, index);
                }
                else
                {
                    target = GetMemberValue(target, element);
                }
 
                if (target == null)
                    return null;
            }
 
            return target;
        }
 
        private static object GetMemberValue(object source, string name)
        {
            if (source == null || string.IsNullOrEmpty(name))
                return null;
 
            const BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            var type = source.GetType();
            var field = type.GetField(name, flags);
            if (field != null)
                return field.GetValue(source);
 
            var property = type.GetProperty(name, flags);
            return property != null && property.GetIndexParameters().Length == 0
                ? property.GetValue(source, null)
                : null;
        }
 
        private static object GetIndexedValue(object source, string name, int index)
        {
            if (GetMemberValue(source, name) is not IEnumerable enumerable)
                return null;
 
            var enumerator = enumerable.GetEnumerator();
            using var disposableEnumerator = enumerator as IDisposable;
            for (var i = 0; i <= index; i++)
            {
                if (!enumerator.MoveNext())
                    return null;
            }
 
            return enumerator.Current;
        }
 
        #endregion
    }
}
#endif