com.wallstop-studios.unity-helpers 2.0.0-rc73.2 → 2.0.0-rc73.3

package/Runtime/Tags/AttributeEffect.cs

@@ -8,6 +8,7 @@
     using System.Text.Json.Serialization;
     using Core.Extension;
     using Core.Helper;
+    using UnityEngine;
 #if ODIN_INSPECTOR
     using Sirenix.OdinInspector;
 #endif

package/Styles/Elements/Progress/ArcedProgressBar.cs

@@ -0,0 +1,345 @@
+namespace WallstopStudios.UnityHelpers.Styles.Elements.Progress
+{
+    using System.ComponentModel;
+    using Core.Helper;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+
+    public sealed class ArcedProgressBar : VisualElement
+    {
+        public enum FillDirection
+        {
+            Forward = 0,
+            Reverse = 1,
+        }
+
+        public const string USSClassName = "arced-progress-bar";
+        public const string USSTrackColorVarName = "--arc-track-color";
+        public const string USSProgressColorVarName = "--arc-progress-color";
+        public const string USSThicknessVarName = "--arc-thickness";
+
+        private float _progress = 0.5f;
+
+        public float Progress
+        {
+            get => _progress;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _progress = Mathf.Clamp01(value);
+                MarkDirtyRepaint();
+            }
+        }
+
+        private float _radius = 50f;
+
+        public float Radius
+        {
+            get => _radius;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _radius = Mathf.Max(1f, value);
+                UpdateSize();
+                MarkDirtyRepaint();
+            }
+        }
+
+        private float _thickness = 10f;
+
+        public float Thickness
+        {
+            get => _thickness;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _thickness = Mathf.Max(1f, value);
+                UpdateSize();
+                MarkDirtyRepaint();
+            }
+        }
+
+        private float _startAngleDegrees = -90f;
+
+        public float StartAngleDegrees
+        {
+            get => _startAngleDegrees;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _startAngleDegrees = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private float _endAngleDegrees = 90f;
+
+        public float EndAngleDegrees
+        {
+            get => _endAngleDegrees;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _endAngleDegrees = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private FillDirection _fillDirection = FillDirection.Forward;
+
+        public FillDirection Direction
+        {
+            get => _fillDirection;
+            set
+            {
+                _fillDirection = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private bool _roundedCaps = true;
+
+        public bool RoundedCaps
+        {
+            get => _roundedCaps;
+            set
+            {
+                _roundedCaps = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private Color _trackColor = Color.gray;
+
+        public Color TrackColor
+        {
+            get => _trackColor;
+            set
+            {
+                _trackColor = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private Color _progressColor = Color.cyan;
+
+        public Color ProgressColor
+        {
+            get => _progressColor;
+            set
+            {
+                _progressColor = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        public new class UxmlFactory : UxmlFactory<ArcedProgressBar, UxmlTraits> { }
+
+        public new class UxmlTraits : VisualElement.UxmlTraits
+        {
+            private readonly UxmlFloatAttributeDescription _progressAttribute = new()
+            {
+                name = "progress",
+                defaultValue = 0.5f,
+            };
+
+            private readonly UxmlFloatAttributeDescription _radiusAttribute = new()
+            {
+                name = "radius",
+                defaultValue = 50f,
+            };
+
+            private readonly UxmlFloatAttributeDescription _thicknessAttribute = new()
+            {
+                name = "thickness",
+                defaultValue = 10f,
+            };
+
+            private readonly UxmlFloatAttributeDescription _startAngleAttribute = new()
+            {
+                name = "start-angle",
+                defaultValue = -90f,
+            };
+
+            private readonly UxmlFloatAttributeDescription _endAngleAttribute = new()
+            {
+                name = "end-angle",
+                defaultValue = 90f,
+            };
+
+            private readonly UxmlEnumAttributeDescription<FillDirection> _fillDirectionAttribute =
+                new() { name = "fill-direction", defaultValue = FillDirection.Forward };
+
+            private readonly UxmlBoolAttributeDescription _roundedCapsAttribute = new()
+            {
+                name = "rounded-caps",
+                defaultValue = true,
+            };
+
+            private readonly UxmlColorAttributeDescription _trackColorAttribute = new()
+            {
+                name = "track-color-attr",
+                defaultValue = Color.gray,
+            };
+
+            private readonly UxmlColorAttributeDescription _progressColorAttribute = new()
+            {
+                name = "progress-color-attr",
+                defaultValue = Color.cyan,
+            };
+
+            public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
+            {
+                base.Init(ve, bag, cc);
+                if (ve is not ArcedProgressBar bar)
+                {
+                    Debug.LogError(
+                        $"Initialization failed, expected {nameof(ArcedProgressBar)}, found {ve?.GetType()}.)"
+                    );
+                    return;
+                }
+
+                bar.Progress = _progressAttribute.GetValueFromBag(bag, cc);
+                bar.Radius = _radiusAttribute.GetValueFromBag(bag, cc);
+                bar.Thickness = _thicknessAttribute.GetValueFromBag(bag, cc);
+                bar.StartAngleDegrees = _startAngleAttribute.GetValueFromBag(bag, cc);
+                bar.EndAngleDegrees = _endAngleAttribute.GetValueFromBag(bag, cc);
+                bar.Direction = _fillDirectionAttribute.GetValueFromBag(bag, cc);
+                bar.RoundedCaps = _roundedCapsAttribute.GetValueFromBag(bag, cc);
+                bar.TrackColor = _trackColorAttribute.GetValueFromBag(bag, cc);
+                bar.ProgressColor = _progressColorAttribute.GetValueFromBag(bag, cc);
+            }
+        }
+
+        public ArcedProgressBar()
+        {
+            AddToClassList(USSClassName);
+            generateVisualContent += OnGenerateVisualContent;
+            RegisterCallback<CustomStyleResolvedEvent>(OnCustomStyleResolved);
+            UpdateSize();
+        }
+
+        private void UpdateSize()
+        {
+            float diameter = (_radius + _thickness / 2f) * 2f;
+            style.width = diameter;
+            style.height = diameter;
+            style.minWidth = diameter;
+            style.minHeight = diameter;
+        }
+
+        private void OnCustomStyleResolved(CustomStyleResolvedEvent evt)
+        {
+            if (
+                customStyle.TryGetValue(
+                    new CustomStyleProperty<Color>(USSTrackColorVarName),
+                    out Color trackCol
+                )
+            )
+            {
+                _trackColor = trackCol;
+            }
+
+            if (
+                customStyle.TryGetValue(
+                    new CustomStyleProperty<Color>(USSProgressColorVarName),
+                    out Color progressCol
+                )
+            )
+            {
+                _progressColor = progressCol;
+            }
+
+            if (
+                customStyle.TryGetValue(
+                    new CustomStyleProperty<float>(USSThicknessVarName),
+                    out float thickVal
+                )
+            )
+            {
+                _thickness = Mathf.Max(1f, thickVal);
+            }
+
+            MarkDirtyRepaint();
+        }
+
+        private void OnGenerateVisualContent(MeshGenerationContext mgc)
+        {
+            if (_thickness <= 0)
+            {
+                return;
+            }
+
+            Painter2D painter = mgc.painter2D;
+            Rect rect = contentRect;
+            Vector2 center = rect.center;
+
+            painter.lineWidth = _thickness;
+            painter.lineCap = _roundedCaps ? LineCap.Round : LineCap.Butt;
+
+            painter.strokeColor = _trackColor;
+            painter.BeginPath();
+            painter.Arc(center, _radius, _startAngleDegrees, _endAngleDegrees);
+            painter.Stroke();
+
+            if (Mathf.Approximately(_progress, 0f))
+            {
+                return;
+            }
+
+            float startAngle;
+            ArcDirection direction;
+            float sweepAngleDegrees;
+            switch (_fillDirection)
+            {
+                case FillDirection.Forward:
+                {
+                    startAngle = _startAngleDegrees;
+                    direction = ArcDirection.Clockwise;
+                    sweepAngleDegrees =
+                        _progress * (_endAngleDegrees - _startAngleDegrees).PositiveMod(360f);
+                    break;
+                }
+                case FillDirection.Reverse:
+                {
+                    startAngle = _endAngleDegrees;
+                    direction = ArcDirection.CounterClockwise;
+                    sweepAngleDegrees =
+                        -1 * _progress * (_endAngleDegrees - _startAngleDegrees).PositiveMod(360f);
+                    break;
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(_fillDirection),
+                        (int)_fillDirection,
+                        typeof(FillDirection)
+                    );
+                }
+            }
+
+            if (!Mathf.Approximately(sweepAngleDegrees, 0))
+            {
+                painter.strokeColor = _progressColor;
+                painter.BeginPath();
+                painter.Arc(center, _radius, startAngle, startAngle + sweepAngleDegrees, direction);
+                painter.Stroke();
+            }
+        }
+    }
+}

package/Styles/Elements/Progress/ArcedProgressBar.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 113bae024ddc4a39ab3d77e2f34af18a
+timeCreated: 1746719146

package/Styles/Elements/{CircularProgressBar.cs → Progress/CircularProgressBar.cs}

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Styles.Elements
+namespace WallstopStudios.UnityHelpers.Styles.Elements.Progress
 {
     using System.ComponentModel;
     using UnityEngine;
@@ -31,6 +31,10 @@
             get => _progress;
             set
             {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
                 _progress = Mathf.Clamp01(value);
                 MarkDirtyRepaint();
             }
@@ -42,6 +46,10 @@
             get => _radius;
             set
             {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
                 _radius = Mathf.Max(1f, value);
                 UpdateSize();
                 MarkDirtyRepaint();
@@ -54,19 +62,27 @@
             get => _thickness;
             set
             {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
                 _thickness = Mathf.Max(1f, value);
                 UpdateSize();
                 MarkDirtyRepaint();
             }
         }
 
-        private StartPointLocation _startPoint = StartPointLocation.Top;
-        public StartPointLocation StartAt
+        private float _startPoint = GetStartAngleInDegrees(StartPointLocation.Top);
+        public float StartAt
         {
             get => _startPoint;
             set
             {
-                _startPoint = value;
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _startPoint = value % 360f;
                 MarkDirtyRepaint();
             }
         }
@@ -126,8 +142,11 @@
                 defaultValue = 10f,
             };
 
-            private readonly UxmlEnumAttributeDescription<StartPointLocation> _startPointAttribute =
-                new() { name = "start-at", defaultValue = StartPointLocation.Top };
+            private readonly UxmlFloatAttributeDescription _startPointAttribute = new()
+            {
+                name = "start-at",
+                defaultValue = GetStartAngleInDegrees(StartPointLocation.Top),
+            };
 
             private readonly UxmlEnumAttributeDescription<FillDirection> _fillDirectionAttribute =
                 new() { name = "direction", defaultValue = FillDirection.Clockwise };
@@ -222,63 +241,33 @@
             float drawRadius = _radius;
             Vector2 center = rect.center;
 
-            if (_progress <= 0.01f)
+            painter.strokeColor = _trackColor;
+            painter.lineWidth = _thickness;
+            painter.BeginPath();
+            painter.Arc(center, drawRadius, 0f, 360f);
+            painter.Stroke();
+
+            if (Mathf.Approximately(_progress, 0))
             {
-                painter.strokeColor = _trackColor;
-                painter.lineWidth = _thickness;
-                painter.BeginPath();
-                painter.Arc(center, drawRadius, 0f, 360f);
-                painter.Stroke();
                 return;
             }
 
+            ArcDirection direction;
+            float sweepAngleDegrees;
+
             switch (_fillDirection)
             {
-                case FillDirection.CounterClockwise:
+                case FillDirection.Clockwise:
                 {
-                    painter.strokeColor = _progressColor;
-                    painter.lineWidth = _thickness;
-                    painter.BeginPath();
-                    painter.Arc(center, drawRadius, 0f, 360f);
-                    painter.Stroke();
-
-                    float startAngleDegrees = GetStartAngleInDegrees(_startPoint);
-                    float sweepAngleDegrees = -1 * _progress * 360f;
-
-                    painter.strokeColor = _trackColor;
-                    painter.lineWidth = _thickness;
-                    painter.BeginPath();
-                    painter.Arc(
-                        center,
-                        drawRadius,
-                        startAngleDegrees,
-                        (startAngleDegrees + sweepAngleDegrees)
-                    );
-                    painter.Stroke();
-                    return;
+                    direction = ArcDirection.Clockwise;
+                    sweepAngleDegrees = _progress * 360f;
+                    break;
                 }
-                case FillDirection.Clockwise:
+                case FillDirection.CounterClockwise:
                 {
-                    painter.strokeColor = _trackColor;
-                    painter.lineWidth = _thickness;
-                    painter.BeginPath();
-                    painter.Arc(center, drawRadius, 0f, 360f);
-                    painter.Stroke();
-
-                    float startAngleDegrees = GetStartAngleInDegrees(_startPoint);
-                    float sweepAngleDegrees = _progress * 360f;
-
-                    painter.strokeColor = _progressColor;
-                    painter.lineWidth = _thickness;
-                    painter.BeginPath();
-                    painter.Arc(
-                        center,
-                        drawRadius,
-                        startAngleDegrees,
-                        (startAngleDegrees + sweepAngleDegrees)
-                    );
-                    painter.Stroke();
-                    return;
+                    direction = ArcDirection.CounterClockwise;
+                    sweepAngleDegrees = -1 * _progress * 360f;
+                    break;
                 }
                 default:
                 {
@@ -289,9 +278,21 @@
                     );
                 }
             }
+
+            painter.strokeColor = _progressColor;
+            painter.lineWidth = _thickness;
+            painter.BeginPath();
+            painter.Arc(
+                center,
+                drawRadius,
+                _startPoint,
+                _startPoint + sweepAngleDegrees,
+                direction
+            );
+            painter.Stroke();
         }
 
-        private static float GetStartAngleInDegrees(StartPointLocation location)
+        public static float GetStartAngleInDegrees(StartPointLocation location)
         {
             return location switch
             {