Implement basic glow, change circle drawing

Author: Zeffuro

DelvCD/Config/Styles/CircleStyleConfig.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using Dalamud.Interface.Utility;
 
 namespace DelvCD.Config
 {
@@ -34,23 +35,26 @@ public class CircleStyleConfig : IConfigPage
         public int Thickness = 10;
         public int StartAngle = 0;
         public int EndAngle = 360;
-        public CircleDirection Direction = CircleDirection.Clockwise;
+        public CircleDirection Direction = CircleDirection.AntiClockwise;
         public ConfigColor FillColor = new ConfigColor(1, 0.5f, 0.5f, 1);
         public ConfigColor BackgroundColor = new ConfigColor(0, 0, 0, 0.5f);
 
         public bool ShowBorder = true;
         public int BorderThickness = 1;
         public ConfigColor BorderColor = new ConfigColor(0, 0, 0, 1);
 
+        /*
         public bool Chunked = false;
         public bool ChunkedStacksFromTrigger = true;
         public int ChunkCount = 5;
         public int ChunkPadding = 2;
         public ConfigColor IncompleteChunkColor = new ConfigColor(0.6f, 0.6f, 0.6f, 1);
+        */
 
         public bool Glow = false;
         public int GlowThickness = 2;
-        public int GlowSegments = 8;
+        public int GlowSegments = 20;
+        public int GlowPadding = 5;
         public float GlowSpeed = 1f;
         public ConfigColor GlowColor = new ConfigColor(230f / 255f, 150f / 255f, 0f / 255f, 1f);
         public ConfigColor GlowColor2 = new ConfigColor(0f / 255f, 0f / 255f, 0f / 255f, 0f);
@@ -151,6 +155,7 @@ public void DrawConfig(IConfigurable parent, Vector2 size, float padX, float pad
                     }
                 }
 
+                /*
                 // chunked
                 ImGui.NewLine();
                 ImGui.Checkbox("Draw in Chunks", ref Chunked);
@@ -189,6 +194,7 @@ public void DrawConfig(IConfigurable parent, Vector2 size, float padX, float pad
                         IncompleteChunkColor.Vector = vector;
                     }
                 }
+                */
 
                 // glow
                 ImGui.NewLine();
@@ -199,7 +205,10 @@ public void DrawConfig(IConfigurable parent, Vector2 size, float padX, float pad
                     ImGui.DragInt("Thickness##Glow", ref GlowThickness, 1, 1, 16);
 
                     DrawHelpers.DrawNestIndicator(1);
-                    ImGui.DragInt("Glow Segments##Glow", ref GlowSegments, 1, 2, 16);
+                    ImGui.DragInt("Glow Segments##Glow", ref GlowSegments, 1, 2, 40);
+                    
+                    DrawHelpers.DrawNestIndicator(1);
+                    ImGui.DragInt("Glow Padding##Glow", ref GlowPadding, 1, 2, 200);
 
                     DrawHelpers.DrawNestIndicator(1);
                     ImGui.DragFloat("Animation Speed##Glow", ref GlowSpeed, 0.05f, 0, 2f);

DelvCD/Helpers/DrawHelpers.cs

@@ -299,6 +299,41 @@ public static void DrawGlow(Vector2 pos, Vector2 size, int thickness, int segmen
             DrawSegmentedLineHorizontal(drawList, c3.AddY(-thickness), -size.X, thickness, prog, segments, col1, col2);
             DrawSegmentedLineVertical(drawList, c4, thickness, -size.Y, prog, segments, col1, col2);
         }
+        
+        public static void DrawGlowCircle(Vector2 center, float radius, float thickness, float padding, int segments, float speed, ConfigColor col1, ConfigColor col2, ImDrawListPtr drawList)
+        {
+            speed = Math.Abs(speed);
+            int mod = speed == 0 ? 1 : (int)(250 / speed);
+            float prog = (float)(DateTimeOffset.Now.ToUnixTimeMilliseconds() % mod) / mod;
+
+            float angleStep = (float)(Math.PI * 2 / segments);
+            float startAngle = -MathF.PI / 2f;
+
+            for (int i = 0; i < segments; i++)
+            {
+                float currentAngle = startAngle + i * angleStep;
+                float nextAngle = currentAngle + angleStep;
+
+                // Calculate the color gradient
+                float t = ((float)i / segments + prog) % 1;
+                Vector4 color = new Vector4(
+                    col1.Vector.X * (1 - t) + col2.Vector.X * t,
+                    col1.Vector.Y * (1 - t) + col2.Vector.Y * t,
+                    col1.Vector.Z * (1 - t) + col2.Vector.Z * t,
+                    col1.Vector.W * (1 - t) + col2.Vector.W * t
+                );
+
+                uint colorUint = ImGui.ColorConvertFloat4ToU32(color);
+
+                // Draw the glowing segment around the outer edge with padding
+                drawList.PathArcTo(center, radius + thickness / 2 + padding, currentAngle, nextAngle, 2);
+                drawList.PathStroke(colorUint, ImDrawFlags.None, thickness / 2);
+
+                // Draw the glowing segment around the inner edge with padding
+                drawList.PathArcTo(center, radius - thickness / 2 - padding, currentAngle, nextAngle, 2);
+                drawList.PathStroke(colorUint, ImDrawFlags.None, thickness / 2);
+            }
+        }
 
         public static void DrawGlowNGon(Vector2 center, float radius, int thickness, int sides, int segments, float speed, ConfigColor col1, ConfigColor col2, ImDrawListPtr drawList)
         {

DelvCD/UIElements/Circle.cs

@@ -9,6 +9,7 @@
 using System.Text.Json.Serialization;
 using System.Threading;
 using Dalamud.Logging;
+using Dalamud.Plugin.Services;
 
 namespace DelvCD.UIElements
 {
@@ -189,46 +190,32 @@ public override void Draw(Vector2 pos, Vector2? parentSize = null, bool parentVi
                 const int segments = 100;
                 float startAngle = (float)(-Math.PI / 2f + style.StartAngle * (Math.PI / 180f));
                 float endAngle = (float)(-Math.PI / 2f + style.EndAngle * (Math.PI / 180f));
-                
-                if (style.Direction == CircleDirection.AntiClockwise)
-                {
-                    startAngle *= -1;
-                    endAngle *= -1;
-                }
-                
 
                 List<CircleData> circles;
-                if (!style.Chunked)
-                {
-                    circles = new List<CircleData>() { CalculateCircle(startAngle, endAngle, progressValue, progressMaxValue, style.Direction) };
-                }
-                else
-                {
-                    int chunkCount = style.ChunkedStacksFromTrigger ? (int)progressMaxValue : style.ChunkCount;
-                    circles = CalculateChunkedCircles(startAngle, endAngle, progressValue, progressMaxValue, chunkCount, style.ChunkPadding, style.Direction, style.IncompleteChunkColor);
-                }
+                circles = new List<CircleData>() { CalculateCircle(startAngle, endAngle, progressValue, progressMaxValue, style.Direction) };
 
                 foreach (CircleData circle in circles)
                 {
-                    
-                    //PluginLog.Information($"{startAngle}|{endAngle}|{circle.StartAngle}|{circle.EndAngle}");
-
                     // fill
                     ConfigColor fillColor = circle.FillColor ?? style.FillColor;
-                    
+
+                    // Draw background arc first
+                    if (circle.EndAngle != startAngle)
+                    {
+                        drawList.PathArcTo(localPos, style.Radius, circle.StartAngle, endAngle, segments);
+                        drawList.PathStroke(ImGui.ColorConvertFloat4ToU32(style.BackgroundColor.Vector), ImDrawFlags.None, style.Thickness);
+                    }
+
+                    // Draw fill arc on top
                     drawList.PathArcTo(localPos, style.Radius, circle.StartAngle, circle.EndAngle, segments);
                     drawList.PathStroke(ImGui.ColorConvertFloat4ToU32(fillColor.Vector), ImDrawFlags.None, style.Thickness);
 
-                    // anything that remains is background
-                    drawList.PathArcTo(localPos, style.Radius, circle.EndAngle, endAngle, segments);
-                    drawList.PathStroke(ImGui.ColorConvertFloat4ToU32(style.BackgroundColor.Vector), ImDrawFlags.None, style.Thickness);
 
-                    /*
                     if (style.Glow)
                     {
-                        DrawHelpers.DrawGlow(localPos, size, style.GlowThickness, style.GlowSegments, style.GlowSpeed, style.GlowColor, style.GlowColor2, drawList);
+                        DrawHelpers.DrawGlowCircle(localPos, style.Radius, style.Thickness, style.GlowPadding, style.GlowSegments, style.GlowSpeed, style.GlowColor, style.GlowColor2, drawList);
                     }
-                    */
+                    
                 }
                 if (style.ShowBorder)
                 {
@@ -258,65 +245,37 @@ public override void Draw(Vector2 pos, Vector2? parentSize = null, bool parentVi
                 }
             }
         }
-
+        
         private CircleData CalculateCircle(float startAngle, float endAngle, float progress, float max, CircleDirection direction)
         {
             CircleData circle = new();
-            /*
+
             float fillPercent = max == 0 ? 1f : Math.Clamp(progress / max, 0f, 1f);
-            float fillAngle = max == 0 ? endAngle : Math.Clamp(progress / max, startAngle, endAngle);
-            */
-            float current = progress / max;
             float angleRange = endAngle - startAngle;
-            float relativeAngle = startAngle + (angleRange * current);
-            
-            circle.StartAngle = startAngle;
-            circle.EndAngle = relativeAngle;
-            
-            return circle;
-        }
-
-        private List<CircleData> CalculateChunkedCircles(float startAngle, float endAngle, float progress, float max, int count, int padding, CircleDirection direction, ConfigColor incompleteColor)
-        {
-            
-            return new List<CircleData>() { CalculateCircle(startAngle, endAngle, progress, 1, direction) };
-            
-            /*
 
-            int paddingCount = count - 1;
-            int chunkLength = horizontal ?
-                (int)((size.X - (paddingCount * padding)) / count) :
-                (int)((size.Y - (paddingCount * padding)) / count);
-
-            Vector2 chunkSize = horizontal ?
-                new(chunkLength, size.Y) :
-                new(size.X, chunkLength);
-
-            float chunkProgressSize = max / count;
-
-            Vector2 pos = Vector2.Zero;
-            List<CircleData> bars = new(count);
-
-            for (int i = 0; i < count; i++)
+            if (direction == CircleDirection.AntiClockwise)
             {
-                int index = reversed ? count - i - 1 : i;
-                float chunkProgress = Math.Min(progress - (chunkProgressSize * index), chunkProgressSize);
-                CircleData bar = CalculateCircle(pos, chunkSize, chunkProgress, chunkProgressSize, direction);
-
-                pos = horizontal ?
-                    new Vector2(pos.X + padding + chunkLength, pos.Y) :
-                    new Vector2(pos.X, pos.Y + padding + chunkLength);
+                // If anticlockwise, the angle range needs to be reversed
+                angleRange = startAngle - endAngle;
+            }
 
-                if (chunkProgress < chunkProgressSize)
-                {
-                    circle.FillColor = incompleteColor;
-                }
+            float fillAngle = angleRange * fillPercent;
 
-                circles.Add(circle);
+            // Adjusting for direction
+            float relativeAngle;
+            if (direction == CircleDirection.Clockwise)
+            {
+                relativeAngle = startAngle + fillAngle;
+            }
+            else // Anticlockwise
+            {
+                relativeAngle = startAngle - fillAngle;
             }
 
-            return circles;
-            */
+            circle.StartAngle = startAngle;
+            circle.EndAngle = relativeAngle;
+
+            return circle;
         }
 
         public void Resize(Vector2 size, bool conditions)