1.9.0: Added support for attributes for drawing handles in the scene

Editor/Utilities/EditorHandleUtility.cs

@@ -0,0 +1,470 @@
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Module.Inspector.Editor.Utilities
+{
+    public static class EditorHandleUtility
+    {
+        private static readonly Color DEFAULT_AXIS_COLOR = new Color(0.7f, 0.7f, 0.7f, 0.93f);
+        private static readonly Color X_AXIS_COLOR = new Color(0.85882354f, 0.24313726f, 0.11372549f, 0.93f);
+        private static readonly Color Y_AXIS_COLOR = new Color(0.6039216f, 0.9529412f, 0.28235295f, 0.93f);
+        private static readonly Color Z_AXIS_COLOR = new Color(0.22745098f, 0.47843137f, 0.972549f, 0.93f);
+
+        private static readonly Color EDGE_COLOR = new Color(0.6039216f, 0.9529412f, 0.28235295f, 0.93f);
+        private static readonly Color EDGE_COLOR2 = new Color(0.6039216f, 0.9529412f, 0.28235295f, 0.4f);
+        
+        private static readonly Quaternion CIRCLE_CAP_ROTATION = Quaternion.Euler(90f, 0f, 0f);
+        private static readonly Quaternion CIRCLE_CAP_ROTATION2 = Quaternion.Euler(0f, 90f, 0f);
+        private static readonly Quaternion RECTANGLE_CAP_ROTATION = Quaternion.Euler(90f, 0f, 0f);
+        
+        public static Vector2 RectHandle(Vector3 worldPosition, Quaternion worldRotation, Vector2 rectSize, EAxis axii)
+        {
+            float size = HandleUtility.GetHandleSize(worldPosition);
+            float dotSize = size * 0.125f;
+            
+            Handles.matrix = Matrix4x4.TRS(worldPosition, worldRotation * RECTANGLE_CAP_ROTATION, Vector3.one);
+            Color color = Handles.color;
+            
+            Handles.color = EDGE_COLOR;
+            Handles.DrawWireCube(Vector3.zero, rectSize);
+
+            if ((axii & EAxis.X) != 0)
+            {
+                var point = new Vector3(rectSize.x * 0.5f, 0f, 0f);
+                Handles.color = DEFAULT_AXIS_COLOR;
+                point = Handles.Slider(point, Vector3.right, dotSize, Handles.CubeHandleCap, 0.01f);
+                rectSize.x = Mathf.Max(point.x, 0f) * 2f;
+            }
+
+            if ((axii & EAxis.Y) != 0)
+            {
+                var point = new Vector3(0f, rectSize.y * 0.5f, 0f);
+                Handles.color = DEFAULT_AXIS_COLOR;
+                point = Handles.Slider(point, Vector3.up, dotSize, Handles.CubeHandleCap, 0.01f);
+                rectSize.y = Mathf.Max(point.y, 0f) * 2f;
+            }
+            
+            Handles.color = color;
+            Handles.matrix = Matrix4x4.identity;
+            return rectSize;
+        }
+
+        public static float CircleHandle(Vector3 worldPosition, Quaternion worldRotation, float circleSize)
+        {
+            float size = HandleUtility.GetHandleSize(worldPosition);
+            float dotSize = size * 0.125f;
+            
+            Handles.matrix = Matrix4x4.TRS(worldPosition, worldRotation, Vector3.one);
+            Color color = Handles.color;
+            
+            Handles.color = EDGE_COLOR;
+            Handles.CircleHandleCap(-1, Vector3.zero, CIRCLE_CAP_ROTATION, circleSize, EventType.Repaint);
+
+            var point = new Vector3(circleSize, 0f, 0f);
+            Handles.color = DEFAULT_AXIS_COLOR;
+            point = Handles.Slider(point, Vector3.right, dotSize, Handles.CubeHandleCap, 0.01f);
+            circleSize = Mathf.Max(point.x, 0f);
+            
+            Handles.color = color;
+            Handles.matrix = Matrix4x4.identity;
+            return circleSize;
+        }
+        
+        public static float SphereHandle(Vector3 worldPosition, Quaternion worldRotation, float sphereSize)
+        {
+            float size = HandleUtility.GetHandleSize(worldPosition);
+            float dotSize = size * 0.125f;
+            
+            Handles.matrix = Matrix4x4.TRS(worldPosition, worldRotation, Vector3.one);
+            Color color = Handles.color;
+            
+            Handles.color = EDGE_COLOR;
+            Handles.CircleHandleCap(-1, Vector3.zero, CIRCLE_CAP_ROTATION, sphereSize, EventType.Repaint);
+            
+            Handles.color = EDGE_COLOR2;
+            Handles.CircleHandleCap(-1, Vector3.zero, Quaternion.identity, sphereSize, EventType.Repaint);
+            Handles.CircleHandleCap(-1, Vector3.zero, CIRCLE_CAP_ROTATION2, sphereSize, EventType.Repaint);
+
+            var point = new Vector3(sphereSize, 0f, 0f);
+            Handles.color = DEFAULT_AXIS_COLOR;
+            point = Handles.Slider(point, Vector3.right, dotSize, Handles.CubeHandleCap, 0.01f);
+            sphereSize = Mathf.Max(point.x, 0f);
+            
+            Handles.color = color;
+            Handles.matrix = Matrix4x4.identity;
+            return sphereSize;
+        }
+        
+        public static Vector3 BoxHandle(Vector3 worldPosition, Quaternion worldRotation, Vector3 boxSize, EAxis axii = EAxis.All)
+        {
+            float size = HandleUtility.GetHandleSize(worldPosition);
+            float dotSize = size * 0.125f;
+            
+            Handles.matrix = Matrix4x4.TRS(worldPosition, worldRotation, Vector3.one);
+            Color color = Handles.color;
+            
+            Handles.color = EDGE_COLOR;
+            Handles.DrawWireCube(Vector3.zero, boxSize);
+
+            if ((axii & EAxis.X) != 0)
+            {
+                var point = new Vector3(boxSize.x * 0.5f, 0f, 0f);
+                Handles.color = DEFAULT_AXIS_COLOR;
+                point = Handles.Slider(point, Vector3.right, dotSize, Handles.CubeHandleCap, 0.01f);
+                boxSize.x = Mathf.Max(point.x, 0f) * 2f;
+            }
+
+            if ((axii & EAxis.Y) != 0)
+            {
+                var point = new Vector3(0f, boxSize.y * 0.5f, 0f);
+                Handles.color = DEFAULT_AXIS_COLOR;
+                point = Handles.Slider(point, Vector3.up, dotSize, Handles.CubeHandleCap, 0.01f);
+                boxSize.y = Mathf.Max(point.y, 0f) * 2f;
+            }
+            
+            if ((axii & EAxis.Z) != 0)
+            {
+                var point = new Vector3(0f, 0f, boxSize.z * 0.5f);
+                Handles.color = DEFAULT_AXIS_COLOR;
+                point = Handles.Slider(point, Vector3.forward, dotSize, Handles.CubeHandleCap, 0.01f);
+                boxSize.z = Mathf.Max(point.z, 0f) * 2f;
+            }
+
+            Handles.color = color;
+            Handles.matrix = Matrix4x4.identity;
+            return boxSize;
+        }
+        
+        public static Vector3 PositionHandle(Vector3 worldPosition, Quaternion worldRotation, EAxis axii = EAxis.All)
+        {
+            float size = HandleUtility.GetHandleSize(worldPosition);
+            float twoAxisSize = size * 0.1f;
+            Color color = Handles.color;
+            
+            if ((axii & (EAxis.X | EAxis.Y)) == (EAxis.X | EAxis.Y))
+            {
+                Handles.color = Z_AXIS_COLOR;
+                Vector3 offset = worldRotation * new Vector3(twoAxisSize, twoAxisSize, 0f);
+                
+                worldPosition = Handles.Slider2D(worldPosition + offset, 
+                    worldRotation * Vector3.forward, 
+                    worldRotation * Vector3.right,
+                    worldRotation * Vector3.up, twoAxisSize, 
+                    Handles.RectangleHandleCap, 0.01f) - offset;
+            }
+            
+            if ((axii & (EAxis.X | EAxis.Z)) == (EAxis.X | EAxis.Z))
+            {
+                Handles.color = Y_AXIS_COLOR;
+                Vector3 offset = worldRotation * new Vector3(twoAxisSize, 0f, twoAxisSize);
+                
+                worldPosition = Handles.Slider2D(worldPosition + offset, 
+                                    worldRotation * Vector3.up, 
+                                    worldRotation * Vector3.right,
+                                    worldRotation * Vector3.forward, twoAxisSize, 
+                                    Handles.RectangleHandleCap, 0.01f) - offset;
+            }
+            
+            if ((axii & (EAxis.Y | EAxis.Z)) == (EAxis.Y | EAxis.Z))
+            {
+                Handles.color = X_AXIS_COLOR;
+                Vector3 offset = worldRotation * new Vector3(0f, twoAxisSize, twoAxisSize);
+                
+                worldPosition = Handles.Slider2D(worldPosition + offset, 
+                                    worldRotation * Vector3.right, 
+                                    worldRotation * Vector3.up,
+                                    worldRotation * Vector3.forward, twoAxisSize, 
+                                    Handles.RectangleHandleCap, 0.01f) - offset;
+            }
+            
+            if ((axii & EAxis.X) != 0)
+            {
+                Handles.color = X_AXIS_COLOR;
+                worldPosition = Handles.Slider(worldPosition, worldRotation * Vector3.right, size, Handles.ArrowHandleCap, 0.01f);
+            }
+            
+            if ((axii & EAxis.Y) != 0)
+            {
+                Handles.color = Y_AXIS_COLOR;
+                worldPosition = Handles.Slider(worldPosition, worldRotation * Vector3.up, size, Handles.ArrowHandleCap, 0.01f);
+            }
+            
+            if ((axii & EAxis.Z) != 0)
+            {
+                Handles.color = Z_AXIS_COLOR;
+                worldPosition = Handles.Slider(worldPosition, worldRotation * Vector3.forward, size, Handles.ArrowHandleCap, 0.01f);
+            }
+            
+            Handles.color = color;
+            return worldPosition;
+        }
+        
+        public static Quaternion RotationHandle(Vector3 worldPosition, Quaternion worldRotation)
+        {
+            Color color = Handles.color;
+            worldRotation = Handles.RotationHandle(worldRotation, worldPosition);
+            Handles.color = color;
+            return worldRotation;
+        }
+        public static bool TryGetWorldPosition(SerializedProperty serializedProperty, string fieldPosition, Space space, out Vector3 worldPosition)
+        {
+            SerializedProperty spPosition = serializedProperty.GetSibling(fieldPosition);
+
+            if (spPosition != null)
+            {
+                worldPosition = GetWorldPosition(spPosition, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+                worldPosition = transform != null ? transform.position : Vector3.zero;
+            }
+            
+            return spPosition != null;
+        }
+        
+        public static Vector3 GetWorldPosition(SerializedProperty serializedProperty, string fieldPosition, Space space)
+        {
+            Vector3 worldPosition = Vector3.zero;
+            SerializedProperty spPosition = serializedProperty.GetSibling(fieldPosition);
+
+            if (spPosition != null)
+            {
+                worldPosition = GetWorldPosition(spPosition, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+
+                if (transform != null)
+                    worldPosition = transform.position;
+            }
+            
+            return worldPosition;
+        }
+
+        private static Transform GetTransform(SerializedProperty serializedProperty)
+        {
+            Object target = serializedProperty.serializedObject.targetObject;
+            
+            if (target is Component component)
+                return component.transform;
+
+            return null;
+        }
+
+        public static Vector3 GetWorldPosition(SerializedProperty serializedProperty, Space space)
+        {
+            Vector3 worldPosition = Vector3.zero;
+            var requireObjectTransform = true;
+
+            switch (serializedProperty.propertyType)
+            {
+                case SerializedPropertyType.Integer:
+                    worldPosition = new Vector3(serializedProperty.intValue, serializedProperty.intValue, serializedProperty.intValue);
+                    break;
+                case SerializedPropertyType.Float:
+                    worldPosition = new Vector3(serializedProperty.floatValue, serializedProperty.floatValue, serializedProperty.floatValue);
+                    break;
+                case SerializedPropertyType.ObjectReference:
+                    if (serializedProperty.objectReferenceValue != null && serializedProperty.objectReferenceValue is Transform transform)
+                    {
+                        worldPosition = transform.position;
+                        requireObjectTransform = false;
+                    }
+                    break;
+                case SerializedPropertyType.Vector2:
+                    worldPosition = serializedProperty.vector2Value;
+                    break;
+                case SerializedPropertyType.Vector3:
+                    worldPosition = serializedProperty.vector3Value;
+                    break;
+                case SerializedPropertyType.Vector2Int:
+                    worldPosition = new Vector3(serializedProperty.vector2IntValue.x, serializedProperty.vector2IntValue.y, 0.0f);
+                    break;
+                case SerializedPropertyType.Vector3Int:
+                    worldPosition = new Vector3(serializedProperty.vector3IntValue.x, serializedProperty.vector3IntValue.y, serializedProperty.vector3IntValue.z);
+                    break;
+            }
+            
+            if (requireObjectTransform && space == Space.Self)
+            {
+                Transform objectTransform = GetTransform(serializedProperty);
+
+                if (objectTransform != null)
+                    worldPosition = objectTransform.TransformPoint(worldPosition);
+            }
+
+            return worldPosition;
+        }
+        
+        public static void SetWorldPosition(SerializedProperty serializedProperty, string fieldPosition, Vector3 worldPosition, Space space)
+        {
+            SerializedProperty spPosition = serializedProperty.GetSibling(fieldPosition);
+
+            if (spPosition != null)
+            {
+                SetWorldPosition(spPosition, worldPosition, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+
+                if (transform != null)
+                    transform.position = worldPosition;
+            }
+        }
+
+        public static void SetWorldPosition(SerializedProperty serializedProperty, Vector3 worldPosition, Space space)
+        {
+            bool requireObjectTransform = !(serializedProperty.propertyType == SerializedPropertyType.ObjectReference && serializedProperty.objectReferenceValue != null && serializedProperty.objectReferenceValue is Transform);
+            
+            if (requireObjectTransform && space == Space.Self)
+            {
+                Transform objectTransform = GetTransform(serializedProperty);
+
+                if (objectTransform != null)
+                    worldPosition = objectTransform.InverseTransformPoint(worldPosition);
+            }
+            
+            switch (serializedProperty.propertyType)
+            {
+                case SerializedPropertyType.Integer:
+                    serializedProperty.intValue = Mathf.RoundToInt(worldPosition.x);
+                    break;
+                case SerializedPropertyType.Float:
+                    serializedProperty.floatValue = worldPosition.x;
+                    break;
+                case SerializedPropertyType.ObjectReference:
+                    if (serializedProperty.objectReferenceValue != null && serializedProperty.objectReferenceValue is Transform transform)
+                        transform.position = worldPosition;
+                    break;
+                case SerializedPropertyType.Vector2:
+                    serializedProperty.vector2Value = worldPosition;
+                    break;
+                case SerializedPropertyType.Vector3:
+                    serializedProperty.vector3Value = worldPosition;
+                    break;
+                case SerializedPropertyType.Vector2Int:
+                    serializedProperty.vector2IntValue = new Vector2Int(Mathf.RoundToInt(worldPosition.x), Mathf.RoundToInt(worldPosition.y));
+                    break;
+                case SerializedPropertyType.Vector3Int:
+                    serializedProperty.vector3IntValue = new Vector3Int(Mathf.RoundToInt(worldPosition.x), Mathf.RoundToInt(worldPosition.y), Mathf.RoundToInt(worldPosition.z));
+                    break;
+            }
+        }
+        
+        public static bool TryGetWorldRotation(SerializedProperty serializedProperty, string fieldRotation, Space space, out Quaternion worldRotation)
+        {
+            SerializedProperty spRotation = serializedProperty.GetSibling(fieldRotation);
+
+            if (spRotation != null)
+            {
+                worldRotation = GetWorldRotation(spRotation, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+                worldRotation = transform != null ? transform.rotation : Quaternion.identity;
+            }
+            
+            return spRotation != null;
+        }
+
+        public static Quaternion GetWorldRotation(SerializedProperty serializedProperty, string fieldRotation, Space space)
+        {
+            Quaternion worldRotation = Quaternion.identity;
+            SerializedProperty spRotation = serializedProperty.GetSibling(fieldRotation);
+
+            if (spRotation != null)
+            {
+                worldRotation = GetWorldRotation(spRotation, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+
+                if (transform != null)
+                    worldRotation = transform.rotation;
+            }
+            
+            return worldRotation;
+        }
+        
+        public static Quaternion GetWorldRotation(SerializedProperty serializedProperty, Space space)
+        {
+            Quaternion worldRotation = Quaternion.identity;
+            var requireObjectTransform = true;
+
+            switch (serializedProperty.propertyType)
+            {
+                case SerializedPropertyType.ObjectReference:
+                    if (serializedProperty.objectReferenceValue is Transform transform)
+                    {
+                        worldRotation = transform.rotation;
+                        requireObjectTransform = false;
+                    }
+
+                    break;
+                case SerializedPropertyType.Quaternion:
+                    worldRotation = serializedProperty.quaternionValue;
+                    
+                    if (Mathf.Approximately(worldRotation.x, 0.0f) && Mathf.Approximately(worldRotation.y, 0.0f) && Mathf.Approximately(worldRotation.z, 0.0f) && Mathf.Approximately(worldRotation.w, 0.0f))
+                        worldRotation = Quaternion.identity;
+                    break;
+            }
+            
+            if (requireObjectTransform && space == Space.Self)
+            {
+                Transform objectTransform = GetTransform(serializedProperty);
+                
+                if (objectTransform != null)
+                    worldRotation = objectTransform.rotation * worldRotation;
+            }
+            
+            return worldRotation;
+        }
+        
+        public static void SetWorldRotation(SerializedProperty serializedProperty, string fieldRotation, Quaternion worldRotation, Space space)
+        {
+            SerializedProperty spRotation = serializedProperty.GetSibling(fieldRotation);
+
+            if (spRotation != null)
+            {
+                SetWorldRotation(spRotation, worldRotation, space);
+            }
+            else
+            {
+                Transform transform = GetTransform(serializedProperty);
+
+                if (transform != null)
+                    transform.rotation = worldRotation;
+            }
+        }
+        
+        public static void SetWorldRotation(SerializedProperty serializedProperty, Quaternion worldRotation, Space space)
+        {
+            bool requireObjectTransform = !(serializedProperty.propertyType == SerializedPropertyType.ObjectReference && serializedProperty.objectReferenceValue != null && serializedProperty.objectReferenceValue is Transform);
+            
+            if (requireObjectTransform && space == Space.Self)
+            {
+                Transform objectTransform = GetTransform(serializedProperty);
+
+                if (objectTransform != null)
+                    worldRotation = Quaternion.Inverse(objectTransform.rotation) * worldRotation;
+            }
+
+            switch (serializedProperty.propertyType)
+            {
+                case SerializedPropertyType.ObjectReference:
+                    if (serializedProperty.objectReferenceValue is Transform transform)
+                        transform.rotation = worldRotation;
+                    break;
+                case SerializedPropertyType.Quaternion:
+                    serializedProperty.quaternionValue = worldRotation;
+                    break;
+            }
+        }
+    }
+}

Editor/Utilities/EditorHandleUtility.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 45835ab2c4434b40a10616e608e4ce1b
+timeCreated: 1669476070

Editor/Utilities/EditorPropertyUtility.cs

@@ -76,6 +76,7 @@ namespace Module.Inspector.Editor.Utilities
             var valueModifiers = new List<ResultValue<ValueModifierPropertyAttribute, ValueModifierPropertyDrawer>>(2);
             var accessModifiers = new List<ResultValue<AccessModifierPropertyAttribute, AccessModifierPropertyDrawer>>(2);
             var validators = new List<ResultValue<ValidatePropertyAttribute, ValidatePropertyDrawer>>(2);
+            var handleDrawers = new List<ResultValue<HandleDrawerPropertyAttribute, HandlePropertyDrawer>>(2);
             object[] attributes = fieldInfo.GetCustomAttributes(false);
             string tooltip = null;
             var isObsolete = false;
@@ -123,6 +124,13 @@ namespace Module.Inspector.Editor.Utilities
                     if (prop != null)
                         validators.Add(new ResultValue<ValidatePropertyAttribute, ValidatePropertyDrawer>(validator, prop));
                 }
+                else if (att is HandleDrawerPropertyAttribute handleDrawer)
+                {
+                    var prop = InternalCreateInstanceOf<HandlePropertyDrawer>(handleDrawer);
+                    
+                    if (prop != null)
+                        handleDrawers.Add(new ResultValue<HandleDrawerPropertyAttribute, HandlePropertyDrawer>(handleDrawer, prop));
+                }
                 else if (att is TooltipAttribute attTooltip)
                 {
                     tooltip = attTooltip.tooltip;
@@ -139,9 +147,9 @@ namespace Module.Inspector.Editor.Utilities
                 if (string.IsNullOrEmpty(obsoleteText))
                 {
                     if (tooltip != null)
-                        tooltip += $"\n[Obsolete]";
+                        tooltip += "\n[Obsolete]";
                     else
-                        tooltip = $"[Obsolete]";
+                        tooltip = "[Obsolete]";
                 }
                 else
                 {
@@ -152,9 +160,9 @@ namespace Module.Inspector.Editor.Utilities
                 }
             }
 
-            return new Result(drawer, predrawerModifiers, valueModifiers, accessModifiers, validators, tooltip, isObsolete);
+            return new Result(drawer, predrawerModifiers, valueModifiers, accessModifiers, validators, handleDrawers, tooltip, isObsolete);
         }
-
+        
         private static T InternalCreateInstanceOf<T>(AbstractPropertyAttribute att) where T : AbstractPropertyDrawer
         {
             if (CACHED_ATT_TO_DRAWER.TryGetValue(att.GetType(), out Type drawerType))
@@ -181,6 +189,7 @@ namespace Module.Inspector.Editor.Utilities
             public readonly List<ResultValue<ValueModifierPropertyAttribute, ValueModifierPropertyDrawer>> valueModifiers;
             public readonly List<ResultValue<AccessModifierPropertyAttribute, AccessModifierPropertyDrawer>> accessModifiers;
             public readonly List<ResultValue<ValidatePropertyAttribute, ValidatePropertyDrawer>> validators;
+            public readonly List<ResultValue<HandleDrawerPropertyAttribute, HandlePropertyDrawer>> handleDrawers;
             public readonly string tooltip;
             public readonly bool isObsolete;
 
@@ -189,6 +198,7 @@ namespace Module.Inspector.Editor.Utilities
                           List<ResultValue<ValueModifierPropertyAttribute, ValueModifierPropertyDrawer>> valueModifiers,
                           List<ResultValue<AccessModifierPropertyAttribute, AccessModifierPropertyDrawer>> accessModifiers,
                           List<ResultValue<ValidatePropertyAttribute, ValidatePropertyDrawer>> validators,
+                          List<ResultValue<HandleDrawerPropertyAttribute, HandlePropertyDrawer>> handleDrawers,
                           string tooltip,
                           bool isObsolete)
             {
@@ -197,6 +207,7 @@ namespace Module.Inspector.Editor.Utilities
                 this.valueModifiers = valueModifiers;
                 this.accessModifiers = accessModifiers;
                 this.validators = validators;
+                this.handleDrawers = handleDrawers;
                 this.tooltip = tooltip;
                 this.isObsolete = isObsolete;
             }
@@ -244,6 +255,17 @@ namespace Module.Inspector.Editor.Utilities
 
                 return null;
             }
+            
+            public T GetHandleDrawer<T>() where T : HandleDrawerPropertyAttribute
+            {
+                for (var i = 0; i < handleDrawers.Count; i++)
+                {
+                    if (handleDrawers[i].attribute is T att)
+                        return att;
+                }
+
+                return null;
+            }
         }
         
         /// <summary>