com.wallstop-studios.unity-helpers 2.0.0-rc73.1 → 2.0.0-rc73.11

package/Runtime/Utils/TextureScale.cs

@@ -54,8 +54,8 @@
             }
             else
             {
-                ratioX = ((float)tex.width) / newWidth;
-                ratioY = ((float)tex.height) / newHeight;
+                ratioX = (float)tex.width / newWidth;
+                ratioY = (float)tex.height / newHeight;
             }
 
             w = tex.width;
@@ -123,7 +123,7 @@
                 int y2 = (yFloor + 1) * w;
                 int yw = y * w2;
 
-                for (var x = 0; x < w2; x++)
+                for (int x = 0; x < w2; x++)
                 {
                     int xFloor = (int)Mathf.Floor(x * ratioX);
                     float xLerp = x * ratioX - xFloor;
@@ -155,7 +155,7 @@
             {
                 int thisY = (int)(ratioY * y) * w;
                 int yw = y * w2;
-                for (var x = 0; x < w2; x++)
+                for (int x = 0; x < w2; x++)
                 {
                     newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
                 }

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/Progress/CircularProgressBar.cs

@@ -0,0 +1,307 @@
+namespace WallstopStudios.UnityHelpers.Styles.Elements.Progress
+{
+    using System.ComponentModel;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+
+    public sealed class CircularProgressBar : VisualElement
+    {
+        public enum StartPointLocation
+        {
+            Top = 0,
+            Right = 1,
+            Bottom = 2,
+            Left = 3,
+        }
+
+        public enum FillDirection
+        {
+            Clockwise = 0,
+            CounterClockwise = 1,
+        }
+
+        public const string USSClassName = "circular-progress-bar";
+        public const string USSTrackColorVarName = "--track-color";
+        public const string USSProgressColorVarName = "--progress-color";
+        public const string USSThicknessVarName = "--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 _startPoint = GetStartAngleInDegrees(StartPointLocation.Top);
+        public float StartAt
+        {
+            get => _startPoint;
+            set
+            {
+                if (float.IsNaN(value) || float.IsInfinity(value))
+                {
+                    return;
+                }
+                _startPoint = value % 360f;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private FillDirection _fillDirection = FillDirection.Clockwise;
+        public FillDirection Direction
+        {
+            get => _fillDirection;
+            set
+            {
+                _fillDirection = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private Color _trackColor = Color.gray;
+        public Color TrackColor
+        {
+            get => _trackColor;
+            set
+            {
+                _trackColor = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        private Color _progressColor = Color.green;
+        public Color ProgressColor
+        {
+            get => _progressColor;
+            set
+            {
+                _progressColor = value;
+                MarkDirtyRepaint();
+            }
+        }
+
+        public new class UxmlFactory : UxmlFactory<CircularProgressBar, 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 _startPointAttribute = new()
+            {
+                name = "start-at",
+                defaultValue = GetStartAngleInDegrees(StartPointLocation.Top),
+            };
+
+            private readonly UxmlEnumAttributeDescription<FillDirection> _fillDirectionAttribute =
+                new() { name = "direction", defaultValue = FillDirection.Clockwise };
+
+            private readonly UxmlColorAttributeDescription _trackColorAttribute = new()
+            {
+                name = "track-color-attr",
+                defaultValue = Color.gray,
+            };
+
+            private readonly UxmlColorAttributeDescription _progressColorAttribute = new()
+            {
+                name = "progress-color-attr",
+                defaultValue = Color.green,
+            };
+
+            public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
+            {
+                base.Init(ve, bag, cc);
+                if (ve is not CircularProgressBar bar)
+                {
+                    Debug.LogError(
+                        $"Initialization failed, expected {nameof(CircularProgressBar)}, found {ve?.GetType()}.)"
+                    );
+                    return;
+                }
+
+                bar.Progress = _progressAttribute.GetValueFromBag(bag, cc);
+                bar.Radius = _radiusAttribute.GetValueFromBag(bag, cc);
+                bar.Thickness = _thicknessAttribute.GetValueFromBag(bag, cc);
+                bar.StartAt = _startPointAttribute.GetValueFromBag(bag, cc);
+                bar.Direction = _fillDirectionAttribute.GetValueFromBag(bag, cc);
+                bar.TrackColor = _trackColorAttribute.GetValueFromBag(bag, cc);
+                bar.ProgressColor = _progressColorAttribute.GetValueFromBag(bag, cc);
+            }
+        }
+
+        public CircularProgressBar()
+        {
+            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)
+        {
+            Painter2D painter = mgc.painter2D;
+            Rect rect = contentRect;
+
+            float drawRadius = _radius;
+            Vector2 center = rect.center;
+
+            painter.strokeColor = _trackColor;
+            painter.lineWidth = _thickness;
+            painter.BeginPath();
+            painter.Arc(center, drawRadius, 0f, 360f);
+            painter.Stroke();
+
+            if (Mathf.Approximately(_progress, 0))
+            {
+                return;
+            }
+
+            ArcDirection direction;
+            float sweepAngleDegrees;
+
+            switch (_fillDirection)
+            {
+                case FillDirection.Clockwise:
+                {
+                    direction = ArcDirection.Clockwise;
+                    sweepAngleDegrees = _progress * 360f;
+                    break;
+                }
+                case FillDirection.CounterClockwise:
+                {
+                    direction = ArcDirection.CounterClockwise;
+                    sweepAngleDegrees = -1 * _progress * 360f;
+                    break;
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(_fillDirection),
+                        (int)_fillDirection,
+                        typeof(FillDirection)
+                    );
+                }
+            }
+
+            painter.strokeColor = _progressColor;
+            painter.lineWidth = _thickness;
+            painter.BeginPath();
+            painter.Arc(
+                center,
+                drawRadius,
+                _startPoint,
+                _startPoint + sweepAngleDegrees,
+                direction
+            );
+            painter.Stroke();
+        }
+
+        public static float GetStartAngleInDegrees(StartPointLocation location)
+        {
+            return location switch
+            {
+                StartPointLocation.Top => -90f,
+                StartPointLocation.Right => 0f,
+                StartPointLocation.Bottom => 90f,
+                StartPointLocation.Left => 180f,
+                _ => 90f,
+            };
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bb95a7dc54294c45a4a8a41a630ea7cf
+timeCreated: 1746658631