Improved radarcol and hue conversion.

Author: AsYlum-

Ultima/Helpers/HueHelpers.cs

@@ -15,63 +15,77 @@ namespace Ultima.Helpers
 {
     public static class HueHelpers
     {
-        /// <summary>
-        /// Converts RGB value to Hue color
-        /// </summary>
-        /// <param name="color"></param>
-        /// <returns></returns>
-        public static ushort ColorToHue(Color color)
+        // Canonical 8-bit RGB -> 15-bit hue. Uses bit-shift (>>3) packing with the rule:
+        // input all-zero -> 0; else any lane that collapses to 0 -> 1.
+        public static ushort ColorToHue(Color color) => ColorToHueShift(color.R, color.G, color.B);
+
+        // Canonical 15-bit hue -> 32-bit ARGB, expanding 5-bit components via
+        // (c<<3)|(c>>2) so 31 maps to 255 (not 248 as the previous *8 integer math did).
+        public static Color HueToColor(ushort hue)
         {
-            const double scale = 31.0 / 255;
+            return Color.FromArgb(
+                Expand5To8((hue & 0x7c00) >> 10),
+                Expand5To8((hue & 0x03e0) >> 5),
+                Expand5To8(hue & 0x001f));
+        }
 
-            ushort origRed = color.R;
-            var newRed = (ushort)(origRed * scale);
-            if (newRed == 0 && origRed != 0)
-            {
-                newRed = 1;
-            }
+        public static int HueToColorR(ushort hue) => Expand5To8((hue & 0x7c00) >> 10);
+        public static int HueToColorG(ushort hue) => Expand5To8((hue & 0x03e0) >> 5);
+        public static int HueToColorB(ushort hue) => Expand5To8(hue & 0x001f);
 
-            ushort origGreen = color.G;
-            var newGreen = (ushort)(origGreen * scale);
-            if (newGreen == 0 && origGreen != 0)
+        // Canonical RGB->555 packer for this format. Packs each channel via bit-shift:
+        //   result = ((r>>3) << 10) | ((g>>3) << 5) | (b>>3)
+        // Clamp rule: if r|g|b == 0 the pixel is 0 (transparent); else if a lane
+        // downscales to 0, force that lane to 1.
+        public static ushort ColorToHueShift(int r8, int g8, int b8)
+        {
+            if ((r8 | g8 | b8) == 0)
             {
-                newGreen = 1;
+                return 0;
             }
 
-            ushort origBlue = color.B;
-            var newBlue = (ushort)(origBlue * scale);
-            if (newBlue == 0 && origBlue != 0)
+            int r5 = r8 >> 3;
+            int g5 = g8 >> 3;
+            int b5 = b8 >> 3;
+            if (r5 == 0 && g5 == 0 && b5 == 0)
             {
-                newBlue = 1;
+                return 1;
             }
 
-            return (ushort)((newRed << 10) | (newGreen << 5) | newBlue);
+            return (ushort)((r5 << 10) | (g5 << 5) | b5);
         }
 
-        /// <summary>
-        /// Converts Hue color to RGB color
-        /// </summary>
-        /// <param name="hue"></param>
-        /// <returns></returns>
-        public static Color HueToColor(ushort hue)
+        // Rounding alternative: ((c*31 + 127) / 255). Same clamp rule as the shift version.
+        public static ushort ColorToHueRounded(int r8, int g8, int b8)
         {
-            const int scale = 255 / 31;
-            return Color.FromArgb(((hue & 0x7c00) >> 10) * scale, ((hue & 0x3e0) >> 5) * scale, (hue & 0x1f) * scale);
-        }
+            if ((r8 | g8 | b8) == 0)
+            {
+                return 0;
+            }
 
-        public static int HueToColorR(ushort hue)
-        {
-            return ((hue & 0x7c00) >> 10) * (255 / 31);
+            int r5 = (r8 * 31 + 127) / 255;
+            int g5 = (g8 * 31 + 127) / 255;
+            int b5 = (b8 * 31 + 127) / 255;
+            if (r5 == 0 && g5 == 0 && b5 == 0)
+            {
+                return 1;
+            }
+
+            return (ushort)((r5 << 10) | (g5 << 5) | b5);
         }
 
-        public static int HueToColorG(ushort hue)
+        public static void HueExtract5(ushort hue, out int r5, out int g5, out int b5)
         {
-            return ((hue & 0x3e0) >> 5) * (255 / 31);
+            r5 = (hue & 0x7c00) >> 10;
+            g5 = (hue & 0x03e0) >> 5;
+            b5 = hue & 0x001f;
         }
 
-        public static int HueToColorB(ushort hue)
+        // Canonical 5-bit -> 8-bit expansion: replicate top 3 bits into the low ones.
+        // Equivalent to round(c5 * 255 / 31). 0->0, 31->255, monotonic.
+        public static int Expand5To8(int c5)
         {
-            return (hue & 0x1f) * (255 / 31);
+            return (c5 << 3) | (c5 >> 2);
         }
     }
 }

Ultima/Hues.cs

@@ -149,54 +149,6 @@ public static Hue GetHue(int index)
             return List[0];
         }
 
-        /// <summary>
-        /// Converts RGB value to Hue color
-        /// </summary>
-        /// <param name="color"></param>
-        /// <returns></returns>
-        public static ushort ColorToHue(Color color)
-        {
-            const double scale = 31.0 / 255;
-
-            ushort origRed = color.R;
-            var newRed = (ushort)(origRed * scale);
-            if (newRed == 0 && origRed != 0)
-            {
-                newRed = 1;
-            }
-
-            ushort origGreen = color.G;
-            var newGreen = (ushort)(origGreen * scale);
-            if (newGreen == 0 && origGreen != 0)
-            {
-                newGreen = 1;
-            }
-
-            ushort origBlue = color.B;
-            var newBlue = (ushort)(origBlue * scale);
-            if (newBlue == 0 && origBlue != 0)
-            {
-                newBlue = 1;
-            }
-
-            return (ushort)((newRed << 10) | (newGreen << 5) | newBlue);
-        }
-
-        public static int HueToColorR(ushort hue)
-        {
-            return ((hue & 0x7c00) >> 10) * (255 / 31);
-        }
-
-        public static int HueToColorG(ushort hue)
-        {
-            return ((hue & 0x3e0) >> 5) * (255 / 31);
-        }
-
-        public static int HueToColorB(ushort hue)
-        {
-            return (hue & 0x1f) * (255 / 31);
-        }
-
         public static unsafe void ApplyTo(Bitmap bmp, ushort[] colors, bool onlyHueGrayPixels)
         {
             BitmapData bd = bmp.LockBits(
@@ -334,7 +286,15 @@ public Hue(int index, HueDataMul mulStruct)
             Colors = new ushort[32];
             for (int i = 0; i < 32; ++i)
             {
-                Colors[i] = mulStruct.colors[i];
+                ushort c = mulStruct.colors[i];
+                // Clamp c == 0 or any value with the high bit set to 1. The high bit is a
+                // flag in this format, never part of a valid color value.
+                if (c == 0 || c > 0x7fff)
+                {
+                    c = 1;
+                }
+
+                Colors[i] = c;
             }
 
             TableStart = mulStruct.tableStart;

UoFiddler.Controls/Classes/Options.cs

@@ -32,6 +32,12 @@ public static class Options
         /// </summary>
         public static bool ArtItemClip { get; set; } = true;
 
+        /// <summary>
+        /// Strategy used by the RadarColor control to derive a 16-bit color from a tile graphic.
+        /// Runtime-only (not persisted across sessions yet).
+        /// </summary>
+        public static RadarAveragingStrategy RadarColorStrategy { get; set; } = RadarAveragingStrategy.Mean5BankersRound;
+
         /// <summary>
         /// Offsets the sound ids in Sound tab by 1 (POL specific setting)
         /// </summary>