Add Glyph Support Layer

Author: LoneWandererProductions

Solaris/Aurora.xaml

@@ -11,6 +11,7 @@
         <Image Name="LayerOne" />
         <Image Name="LayerTwo" />
         <Image Name="LayerThree" />
+        <Image Name="LayerFour"/>
         <Label Name="Touch" MouseDown="Touch_MouseDown" />
     </Grid>
 </UserControl>

Solaris/Aurora.xaml.cs

@@ -15,6 +15,7 @@
 using System.Windows.Input;
 using Imaging;
 using Mathematics;
+using Solaris.Solaris;
 
 namespace Solaris
 {
@@ -106,6 +107,13 @@ public sealed partial class Aurora
             nameof(AuroraRemoveDisplay), typeof(int), typeof(Aurora),
             new PropertyMetadata(0, OnRemoveDisplayChanged));
 
+        /// <summary>
+        /// The aurora glyphs property
+        /// </summary>
+        public static readonly DependencyProperty AuroraGlyphsProperty = DependencyProperty.Register(
+            nameof(AuroraGlyphs), typeof(Dictionary<int, OverlayGlyph>), typeof(Aurora),
+            new PropertyMetadata(null, OnGlyphsChanged));
+
         #endregion
 
         /// <summary>
@@ -285,6 +293,18 @@ public bool AuroraGrid
             set => SetValue(AuroraGridProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets the aurora glyphs.
+        /// </summary>
+        /// <value>
+        /// The aurora glyphs.
+        /// </value>
+        public Dictionary<int, OverlayGlyph>? AuroraGlyphs
+        {
+            get => (Dictionary<int, OverlayGlyph>?)GetValue(AuroraGlyphsProperty);
+            set => SetValue(AuroraGlyphsProperty, value);
+        }
+
         #endregion
 
         #region Dependency Property Callbacks (Safe execution)
@@ -412,6 +432,17 @@ private static void OnRemoveDisplayChanged(DependencyObject d, DependencyPropert
             control.LayerThree.Source = newBmp?.ToBitmapImage();
         }
 
+        /// <summary>
+        /// Called when [glyphs changed].
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <param name="e">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
+        private static void OnGlyphsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var control = (Aurora)d;
+            control.UpdateGlyphLayer();
+        }
+
         #endregion
 
         #region Setup and Memory Management
@@ -468,6 +499,15 @@ private void ReplaceThirdLayer(Bitmap? newBitmap)
             // Only assign if required, usually overlaid later
         }
 
+        /// <summary>
+        /// Redraws only the vector annotation layer cleanly without touching heavy ground assets.
+        /// </summary>
+        public void UpdateGlyphLayer()
+        {
+            var overlayBmp = Helper.GenerateGlyphOverlay(AuroraWidth, AuroraHeight, AuroraTextureSize, AuroraGlyphs);
+            LayerFour.Source = overlayBmp?.ToBitmapImage();
+        }
+
         /// <summary>
         /// Handles the MouseDown event of the Touch control.
         /// </summary>
@@ -488,4 +528,4 @@ private void Touch_MouseDown(object sender, MouseButtonEventArgs e)
 
         #endregion
     }
-}
+}

Solaris/Helper.cs

@@ -6,15 +6,16 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
-using ExtendedSystemObjects;
-using Imaging;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 using System.Threading.Tasks;
 using System.Windows.Media;
+using ExtendedSystemObjects;
+using Imaging;
+using Solaris.Solaris;
 using Brushes = System.Drawing.Brushes;
 
 namespace Solaris
@@ -170,6 +171,63 @@ internal static ImageSource GenerateNumbers(int width, int height, int textureSi
             return bitmap.ToBitmapImage();
         }
 
+        /// <summary>
+        /// Generates a transparent vector overlay layer hosting crisp numbers or Unicode symbols.
+        /// </summary>
+        /// <param name="width">The width.</param>
+        /// <param name="height">The height.</param>
+        /// <param name="textureSize">Size of the texture.</param>
+        /// <param name="glyphMap">The glyph map.</param>
+        /// <returns>Bitmap representing the glyph overlay.</returns>
+        internal static Bitmap GenerateGlyphOverlay(
+            int width, int height, int textureSize,
+            Dictionary<int, OverlayGlyph>? glyphMap)
+        {
+            var overlayFrame = new Bitmap(width * textureSize, height * textureSize);
+
+            if (glyphMap == null || glyphMap.Count == 0) return overlayFrame;
+
+            using (var g = Graphics.FromImage(overlayFrame))
+            {
+                // THE GRIP: Enable high-fidelity vector text rendering
+                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
+
+                // Establish string formatting rules to ensure symbols center perfectly inside the cell block
+                using (var sf = new StringFormat())
+                {
+                    sf.Alignment = StringAlignment.Center;
+                    sf.LineAlignment = StringAlignment.Center;
+
+                    foreach (var kp in glyphMap)
+                    {
+                        int tileIndex = kp.Key;
+                        OverlayGlyph glyph = kp.Value;
+
+                        if (string.IsNullOrEmpty(glyph.Symbol)) continue;
+
+                        // Map flat index location straight into 2D chessboard pixel boundaries
+                        int cellX = (tileIndex % width) * textureSize;
+                        int cellY = (tileIndex / width) * textureSize;
+
+                        // Calculate the exact destination boundaries of the chessboard cell space
+                        var targetRect = new RectangleF(cellX, cellY, textureSize, textureSize);
+
+                        // Build font family profile dynamically
+                        var fontStyle = glyph.IsBold ? System.Drawing.FontStyle.Bold : System.Drawing.FontStyle.Regular;
+                        using (var font = new Font(glyph.FontName, glyph.FontSize, fontStyle))
+                        using (var brush = new SolidColorBrush(glyph.Color))
+                        {
+                            // Draw the crisp vector character straight onto the bitmap buffer plane
+                            g.DrawString(glyph.Symbol, font, brush, targetRect, sf);
+                        }
+                    }
+                }
+            }
+
+            return overlayFrame;
+        }
+
         /// <summary>
         /// Adds a tile to the map.
         /// </summary>

Solaris/OverlayGlyph.cs

@@ -0,0 +1,59 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Solaris
+ * FILE:        OverlayGlyph.cs
+ * PURPOSE:     Handle the overlay glyphs, which are drawn on top of the tile and can be used to display additional information like health, damage, or other status effects.
+ * PROGRAMER:   Peter Geinitz (Wayfarer)
+ */
+
+namespace Solaris
+{
+    namespace Solaris
+    {
+        public sealed class OverlayGlyph
+        {
+            /// <summary>
+            /// Gets or sets the symbol.
+            /// E.g., "⚔", "🪙", "💧", or "4"
+            /// </summary>
+            /// <value>
+            /// The symbol.
+            /// </value>
+            public string Symbol { get; set; } = string.Empty;
+
+            /// <summary>
+            /// Gets or sets the color.
+            /// </summary>
+            /// <value>
+            /// The color.
+            /// </value>
+            public System.Drawing.Color Color { get; set; } = System.Drawing.Color.Gold;
+
+            /// <summary>
+            /// Gets or sets the name of the font.
+            /// Handles Unicode vectors out of the box
+            /// </summary>
+            /// <value>
+            /// The name of the font.
+            /// </value>
+            public string FontName { get; set; } = "Segoe UI Symbol";
+
+            /// <summary>
+            /// Gets or sets the size of the font.
+            /// Scaled proportionally to match your TileSize
+            /// </summary>
+            /// <value>
+            /// The size of the font.
+            /// </value>
+            public float FontSize { get; set; } = 14f;
+
+            /// <summary>
+            /// Gets or sets a value indicating whether this instance is bold.
+            /// </summary>
+            /// <value>
+            ///   <c>true</c> if this instance is bold; otherwise, <c>false</c>.
+            /// </value>
+            public bool IsBold { get; set; } = true;
+        }
+    }
+}