Update README.md

* ....

* Strix 4 Zone RGB

app/AppConfig.cs

@@ -355,7 +355,7 @@ public static class AppConfig
 
     public static bool IsStrixLimitedRGB()
     {
-        return ContainsModel("G614JV") || ContainsModel("G614JZ") || ContainsModel("G512LI") || ContainsModel("G513RS");
+        return ContainsModel("G614JV") || ContainsModel("G614JZ") || ContainsModel("G512LI") || ContainsModel("G513RS") || ContainsModel("G513RM") || ContainsModel("G713PV");
     }
 
     public static bool IsZ13()

app/GHelper.csproj

@@ -15,7 +15,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.131</AssemblyVersion>
+    <AssemblyVersion>0.133</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

app/Gpu/GPUModeControl.cs

@@ -54,7 +54,7 @@ namespace GHelper.Gpu
             AppConfig.Set("gpu_mode", gpuMode);
             settings.VisualiseGPUMode(gpuMode);
 
-            Aura.ApplyGPUColor();
+            Aura.CustomRGB.ApplyGPUColor();
 
         }
 

app/Helpers/ColorUtilities.cs

@@ -1,6 +1,8 @@
-namespace GHelper.Helpers
+using System.Runtime.CompilerServices;
+
+namespace GHelper.Helpers
 {
-    public class ColorUtilities
+    public class ColorUtils
     {
         // Method to get the weighted average between two colors
         public static Color GetWeightedAverage(Color color1, Color color2, float weight)
@@ -16,6 +18,144 @@
 
             return Color.FromArgb(red, green, blue);
         }
+
+        public static Color GetMidColor(Color color1, Color color2)
+        {
+            return Color.FromArgb((color1.R + color2.R) / 2,
+                (color1.G + color2.G) / 2,
+                (color1.B + color2.B) / 2);
+        }
+
+        public class HSV
+        {
+            public double Hue { get; set; }
+            public double Saturation { get; set; }
+            public double Value { get; set; }
+
+            public Color ToRGB()
+            {
+                var hue = Hue * 6;
+                var saturation = Saturation;
+                var value = Value;
+
+                double red;
+                double green;
+                double blue;
+
+                if (saturation == 0)
+                {
+                    red = green = blue = value;
+                }
+                else
+                {
+                    var i = Convert.ToInt32(Math.Floor(hue));
+                    var f = hue - i;
+                    var p = value * (1 - saturation);
+                    var q = value * (1 - saturation * f);
+                    var t = value * (1 - saturation * (1 - f));
+                    int mod = i % 6;
+
+                    red = new[] { value, q, p, p, t, value }[mod];
+                    green = new[] { t, value, value, q, p, p }[mod];
+                    blue = new[] { p, p, t, value, value, q }[mod];
+                }
+
+                return Color.FromArgb(Convert.ToInt32(red * 255), Convert.ToInt32(green * 255), Convert.ToInt32(blue * 255));
+            }
+
+            public static HSV ToHSV(Color rgb)
+            {
+                double red = rgb.R / 255.0;
+                double green = rgb.G / 255.0;
+                double blue = rgb.B / 255.0;
+                var min = Math.Min(red, Math.Min(green, blue));
+                var max = Math.Max(red, Math.Max(green, blue));
+                var delta = max - min;
+                double hue;
+                double saturation = 0;
+                var value = max;
+
+                if (max != 0)
+                    saturation = delta / max;
+
+                if (delta == 0)
+                    hue = 0;
+                else
+                {
+                    if (red == max)
+                        hue = (green - blue) / delta + (green < blue ? 6 : 0);
+                    else if (green == max)
+                        hue = 2 + (blue - red) / delta;
+                    else
+                        hue = 4 + (red - green) / delta;
+
+                    hue /= 6;
+                }
+
+                return new HSV { Hue = hue, Saturation = saturation, Value = value };
+            }
+
+            public static Color UpSaturation(Color rgb, float increse = 0.2f) //make color more colored
+            {
+                if (rgb.R == rgb.G && rgb.G == rgb.B)
+                    return rgb;
+                var hsv_color = ToHSV(rgb);
+                hsv_color.Saturation = Math.Min(hsv_color.Saturation + increse, 1.00f);
+                return hsv_color.ToRGB();
+            }
+
+        }
+
+        public class SmoothColor
+        {
+            public Color RGB
+            {
+                get { return Interpolate(); }
+                set { clr = value; }
+            }
+
+            Color Interpolate()
+            {
+                clr_ = ColorInterpolator.InterpolateBetween(clr, clr_, smooth);
+                return clr_;
+            }
+
+            private float smooth = 0.65f; //smooth
+            private Color clr = new Color();
+            private Color clr_ = new Color();
+
+            static class ColorInterpolator
+            {
+                delegate byte ComponentSelector(Color color);
+                static ComponentSelector _redSelector = color => color.R;
+                static ComponentSelector _greenSelector = color => color.G;
+                static ComponentSelector _blueSelector = color => color.B;
+
+                public static Color InterpolateBetween(Color endPoint1, Color endPoint2, double lambda)
+                {
+                    if (lambda < 0 || lambda > 1)
+                        throw new ArgumentOutOfRangeException("lambda");
+
+                    if (endPoint1 != endPoint2)
+                    {
+                        return Color.FromArgb(
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _redSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _greenSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _blueSelector)
+                        );
+                    }
+
+                    return endPoint1;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static byte InterpolateComponent(Color end1, Color end2, double lambda, ComponentSelector selector)
+                {
+                    return (byte)(selector(end1) + (selector(end2) - selector(end1)) * lambda);
+                }
+            }
+
+        }
     }
 
 }

app/Input/InputDispatcher.cs

@@ -84,6 +84,9 @@ namespace GHelper.Input
                 Logger.WriteLine("Optimization service is running");
 
             InitBacklightTimer();
+
+            if (AppConfig.ContainsModel("VivoBook")) Program.acpi.DeviceSet(AsusACPI.FnLock, AppConfig.Is("fn_lock") ? 1 : 0, "FnLock");
+
         }
 
         public void InitBacklightTimer()
@@ -191,7 +194,7 @@ namespace GHelper.Input
                     KeyboardHook.KeyKeyPress((Keys)hexKeys[0], (Keys)hexKeys[1]);
                     break;
                 case 3:
-                    KeyboardHook.KeyKeyKeyPress((Keys)hexKeys[0], (Keys)hexKeys[1], (Keys)hexKeys[3]);
+                    KeyboardHook.KeyKeyKeyPress((Keys)hexKeys[0], (Keys)hexKeys[1], (Keys)hexKeys[2]);
                     break;
                 default:
                     LaunchProcess(command);
@@ -308,9 +311,6 @@ namespace GHelper.Input
                     case Keys.F11:
                         SleepEvent();
                         break;
-                    case Keys.F12:
-                        KeyboardHook.KeyKeyPress(Keys.LWin, Keys.A);
-                        break;
                     case Keys.VolumeDown:
                         KeyProcess("m1");
                         break;
@@ -509,7 +509,7 @@ namespace GHelper.Input
             AppConfig.Set("fn_lock", fnLock);
 
             if (AppConfig.ContainsModel("VivoBook"))
-                Program.acpi.DeviceSet(AsusACPI.FnLock, fnLock == 1 ? 0 : 1, "FnLock");
+                Program.acpi.DeviceSet(AsusACPI.FnLock, fnLock == 1 ? 1 : 0, "FnLock");
             else
                 Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
 

app/Input/KeyboardHook.cs

@@ -40,10 +40,13 @@ public sealed class KeyboardHook : IDisposable
         keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
         keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
 
+        if (sleep > 0)
+        {
+            Thread.Sleep(sleep);
+        }
+
         keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
-        if (sleep > 0) Thread.Sleep(sleep);
         keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
-        if (sleep > 0) Thread.Sleep(sleep);
         keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
     }
 

app/Input/KeyboardListener.cs

@@ -26,8 +26,6 @@ namespace GHelper.Input
                 return;
             }
 
-            input.ReadTimeout = int.MaxValue;
-
             Logger.WriteLine($"Input: {input.Device.DevicePath}");
 
             var task = Task.Run(() =>
@@ -44,6 +42,7 @@ namespace GHelper.Input
                             break;
                         }
 
+                        input.ReadTimeout = int.MaxValue;
 
                         var data = input.Read();
                         if (data.Length > 1 && data[0] == AsusHid.INPUT_ID && data[1] > 0 && data[1] != 236)

app/Peripherals/PeripheralsProvider.cs

@@ -239,6 +239,7 @@ namespace GHelper.Peripherals
             timer.Stop();
             Logger.WriteLine("HID Device Event: Checking for new ASUS Mice");
             DetectAllAsusMice();
+            if (AppConfig.IsZ13()) Program.inputDispatcher.Init();
         }
     }
 }

app/Program.cs

@@ -97,7 +97,7 @@ namespace GHelper
 
             gpuControl.InitXGM();
 
-            SetAutoModes(init : true);
+            SetAutoModes(init: true);
 
             // Subscribing for system power change events
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;

app/Properties/Resources.Designer.cs

@@ -110,6 +110,36 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon dot_eco {
+            get {
+                object obj = ResourceManager.GetObject("dot_eco", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon dot_standard {
+            get {
+                object obj = ResourceManager.GetObject("dot_standard", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon dot_ultimate {
+            get {
+                object obj = ResourceManager.GetObject("dot_ultimate", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
         /// </summary>

app/Properties/Resources.resx

@@ -292,4 +292,13 @@
   <data name="MFont" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Font.otf;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </data>
+  <data name="dot_eco" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dot-eco.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="dot_standard" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dot-standard.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="dot_ultimate" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dot-ultimate.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
 </root>

app/Settings.cs

@@ -1177,11 +1177,13 @@ namespace GHelper
                     buttonOptimized.Activated = GPUAuto;
                     labelGPU.Text = Properties.Strings.GPUMode + ": " + Properties.Strings.GPUModeEco;
                     Program.trayIcon.Icon = Properties.Resources.eco;
+                    Icon = Properties.Resources.dot_eco;
                     break;
                 case AsusACPI.GPUModeUltimate:
                     buttonUltimate.Activated = true;
                     labelGPU.Text = Properties.Strings.GPUMode + ": " + Properties.Strings.GPUModeUltimate;
                     Program.trayIcon.Icon = Properties.Resources.ultimate;
+                    Icon = Properties.Resources.dot_ultimate;
                     break;
                 default:
                     buttonOptimized.BorderColor = colorStandard;
@@ -1189,6 +1191,7 @@ namespace GHelper
                     buttonOptimized.Activated = GPUAuto;
                     labelGPU.Text = Properties.Strings.GPUMode + ": " + Properties.Strings.GPUModeStandard;
                     Program.trayIcon.Icon = Properties.Resources.standard;
+                    Icon = Properties.Resources.dot_standard;
                     break;
             }
 

app/USB/AsusHid.cs

@@ -12,67 +12,89 @@ public static class AsusHid
 
     static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6, 0x1abe };
 
-    static HidStream auraStream;
+    static HidStream? auraStream;
 
-    public static HidStream FindHidStream(byte reportId, int minFeatureLength = 1)
+    public static IEnumerable<HidDevice>? FindDevices(byte reportId)
     {
         HidDeviceLoader loader = new HidDeviceLoader();
-        var deviceList = loader.GetDevices(ASUS_ID).Where(device => deviceIds.Contains(device.ProductID));
+        IEnumerable<HidDevice> deviceList;
 
-        foreach (var device in deviceList) if (device.CanOpen)
-            {
-                try
-                {
-                    var config = new OpenConfiguration();
-                    config.SetOption(OpenOption.Interruptible, false);
-                    config.SetOption(OpenOption.Exclusive, false);
-                    config.SetOption(OpenOption.Priority, 10);
-                    HidStream hidStream = device.Open();
+        try
+        {
+            deviceList = loader.GetDevices(ASUS_ID).Where(device => deviceIds.Contains(device.ProductID) && device.CanOpen && device.GetMaxFeatureReportLength() > 0);
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Error enumerating HID devices: {ex.Message}");
+            yield break;
+        }
 
-                    if (device.GetMaxFeatureReportLength() >= minFeatureLength)
-                    {
-                        var reportDescriptor = device.GetReportDescriptor();
-                        if (reportDescriptor.TryGetReport(ReportType.Feature, reportId, out _))
-                        {
-                            return hidStream;
-                        }
-                    }
+        foreach (var device in deviceList)
+            if (device.GetReportDescriptor().TryGetReport(ReportType.Feature, reportId, out _))
+                yield return device;
+    }
 
-                    hidStream.Close();
-                    hidStream.Dispose();
-                }
-                catch (Exception ex)
-                {
-                    Debug.WriteLine($"Error accessing HID device: {ex.Message}");
-                }
-            }
+    public static HidStream? FindHidStream(byte reportId)
+    {
+        try
+        {
+            return FindDevices(reportId)?.FirstOrDefault()?.Open();
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Error accessing HID device: {ex.Message}");
+        }
 
         return null;
     }
 
-    static void WriteData(HidStream stream, byte[] data, string log = "USB")
+    public static void WriteInput(byte[] data, string log = "USB")
     {
-        try
+        foreach (var device in FindDevices(INPUT_ID))
         {
-            stream.Write(data);
-            Logger.WriteLine($"{log} " + stream.Device.ProductID + ": " + BitConverter.ToString(data));
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine($"Error writing {log} to HID device: {ex.Message} {BitConverter.ToString(data)}");
+            try
+            {
+                using (var stream = device.Open())
+                {
+                    var payload = new byte[device.GetMaxFeatureReportLength()];
+                    Array.Copy(data, payload, data.Length);
+                    stream.SetFeature(payload);
+                    Logger.WriteLine($"{log} Feature {device.ProductID.ToString("X")}|{device.GetMaxFeatureReportLength()}: {BitConverter.ToString(data)}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine($"Error setting feature {device.GetMaxFeatureReportLength()} {device.DevicePath}: {BitConverter.ToString(data)} {ex.Message}");
+
+            }
         }
     }
 
-    public static void Write(byte[] data, byte reportId = AURA_ID, string log = "USB")
+    public static void Write(byte[] data, string log = "USB")
     {
-        using (var stream = FindHidStream(reportId))
-            WriteData(stream, data, log);
+        Write(new List<byte[]> { data }, log);
     }
-    public static void Write(List<byte[]> dataList, byte reportId = AURA_ID)
+
+    public static void Write(List<byte[]> dataList, string log = "USB")
     {
-        using (var stream = FindHidStream(reportId))
-            foreach (var data in dataList)
-                WriteData(stream, data);
+        var devices = FindDevices(AURA_ID);
+        if (devices is null) return;
+
+        try
+        {
+            foreach (var device in devices)
+                using (var stream = device.Open())
+                    foreach (var data in dataList)
+                    {
+                        stream.Write(data);
+                        Logger.WriteLine($"{log} {device.ProductID.ToString("X")}: {BitConverter.ToString(data)}");
+                    }
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Error writing {log}: {ex.Message} ");
+        }
+
     }
 
     public static void WriteAura(byte[] data)
@@ -88,7 +110,7 @@ public static class AsusHid
         catch (Exception ex)
         {
             auraStream.Dispose();
-            Debug.WriteLine($"Error writing data to HID device: {ex.Message}");
+            Debug.WriteLine($"Error writing data to HID device: {ex.Message} {BitConverter.ToString(data)}");
         }
     }
 

app/USB/Aura.cs

@@ -1,5 +1,9 @@
 using GHelper.Gpu;
 using GHelper.Helpers;
+using GHelper.Input;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
 using System.Text;
 
 namespace GHelper.USB
@@ -47,6 +51,7 @@ namespace GHelper.USB
         Flash = 12,
         HEATMAP = 20,
         GPUMODE = 21,
+        AMBIENT = 22,
     }
 
     public enum AuraSpeed : int
@@ -63,6 +68,8 @@ namespace GHelper.USB
         static byte[] MESSAGE_APPLY = { AsusHid.AURA_ID, 0xb4 };
         static byte[] MESSAGE_SET = { AsusHid.AURA_ID, 0xb5, 0, 0, 0 };
 
+        static readonly int AURA_ZONES = 8;
+
         private static AuraMode mode = AuraMode.AuraStatic;
         private static AuraSpeed speed = AuraSpeed.Normal;
 
@@ -71,6 +78,7 @@ namespace GHelper.USB
 
         static bool isACPI = AppConfig.IsTUF() || AppConfig.IsVivobook();
         static bool isStrix = AppConfig.IsStrix();
+        static bool isStrix4Zone = AppConfig.IsStrixLimitedRGB();
 
         static public bool isSingleColor = false;
 
@@ -93,7 +101,8 @@ namespace GHelper.USB
             { AuraMode.AuraRainbow, Properties.Strings.AuraRainbow },
             { AuraMode.AuraStrobe, Properties.Strings.AuraStrobe },
             { AuraMode.HEATMAP, "Heatmap"},
-            { AuraMode.GPUMODE, "GPU Mode" }
+            { AuraMode.GPUMODE, "GPU Mode" },
+            { AuraMode.AMBIENT, "Ambient"},
         };
 
         private static Dictionary<AuraMode, string> _modesStrix = new Dictionary<AuraMode, string>
@@ -111,6 +120,7 @@ namespace GHelper.USB
             { AuraMode.Comet, "Comet" },
             { AuraMode.Flash, "Flash" },
             { AuraMode.HEATMAP, "Heatmap"},
+            { AuraMode.AMBIENT, "Ambient"},
         };
 
         static Aura()
@@ -119,33 +129,11 @@ namespace GHelper.USB
             isSingleColor = AppConfig.IsSingleColor(); // Mono Color
 
             if (AppConfig.ContainsModel("GA402X") || AppConfig.ContainsModel("GA402N"))
-                using (var stream = AsusHid.FindHidStream(AsusHid.AURA_ID))
-                {
-                    if (stream is null) return;
-                    if (stream.Device.ReleaseNumberBcd == 22 || stream.Device.ReleaseNumberBcd == 23) isSingleColor = true;
-                    stream.Close();
-                }
-        }
-
-        private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
-        {
-            SetHeatmap();
-        }
-
-        static void SetHeatmap(bool init = false)
-        {
-            float cpuTemp = (float)HardwareControl.GetCPUTemp();
-            int freeze = 20, cold = 40, warm = 65, hot = 90;
-            Color color;
-
-            //Debug.WriteLine(cpuTemp);
-
-            if (cpuTemp < cold) color = ColorUtilities.GetWeightedAverage(Color.Blue, Color.Green, ((float)cpuTemp - freeze) / (cold - freeze));
-            else if (cpuTemp < warm) color = ColorUtilities.GetWeightedAverage(Color.Green, Color.Yellow, ((float)cpuTemp - cold) / (warm - cold));
-            else if (cpuTemp < hot) color = ColorUtilities.GetWeightedAverage(Color.Yellow, Color.Red, ((float)cpuTemp - warm) / (hot - warm));
-            else color = Color.Red;
-
-            ApplyColor(color, init);
+            {
+                var device = AsusHid.FindDevices(AsusHid.AURA_ID).FirstOrDefault();
+                if (device is null) return;
+                if (device.ReleaseNumberBcd == 22 || device.ReleaseNumberBcd == 23) isSingleColor = true;
+            }
         }
 
         public static Dictionary<AuraSpeed, string> GetSpeeds()
@@ -218,6 +206,22 @@ namespace GHelper.USB
             return mode == AuraMode.AuraBreathe && !isACPI;
         }
 
+        private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (!InputDispatcher.backlightActivity)
+                return;
+
+            if (Mode == AuraMode.HEATMAP)
+            {
+                CustomRGB.ApplyHeatmap();
+            }
+            else if (Mode == AuraMode.AMBIENT)
+            {
+                CustomRGB.ApplyAmbient();
+            }
+        }
+
+
         public static byte[] AuraMessage(AuraMode mode, Color color, Color color2, int speed, bool mono = false)
         {
 
@@ -260,9 +264,9 @@ namespace GHelper.USB
                 if (delay) await Task.Delay(TimeSpan.FromSeconds(1));
                 if (isACPI) Program.acpi.TUFKeyboardBrightness(brightness);
 
-                AsusHid.Write(new byte[] { AsusHid.AURA_ID, 0xba, 0xc5, 0xc4, (byte)brightness }, AsusHid.AURA_ID, log);
-                if (AppConfig.ContainsModel("GA503")) 
-                    AsusHid.Write(new byte[] { AsusHid.INPUT_ID, 0xba, 0xc5, 0xc4, (byte)brightness }, AsusHid.INPUT_ID, log);
+                AsusHid.Write(new byte[] { AsusHid.AURA_ID, 0xba, 0xc5, 0xc4, (byte)brightness }, log);
+                if (AppConfig.ContainsModel("GA503"))
+                    AsusHid.WriteInput(new byte[] { AsusHid.INPUT_ID, 0xba, 0xc5, 0xc4, (byte)brightness }, log);
             });
 
 
@@ -355,6 +359,164 @@ namespace GHelper.USB
 
         }
 
+        static byte[] packetMap = new byte[]
+        {
+/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
+            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
+
+/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
+            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
+
+/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
+            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
+
+/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
+            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
+
+/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
+            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
+
+/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
+            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
+
+/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
+           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+
+/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
+           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
+
+/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
+           137, 159, 160, 161, 142,  0,   2,   3,   4,   5,
+
+/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
+             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
+
+};
+
+
+        static byte[] packetZone = new byte[]
+        {
+/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
+            0,   0,   0,   1,   1,   1,   1,   1,   2,   2,
+
+/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
+            2,   3,   3,   3,   0,   0,    0,   0,   1 ,  1,
+
+/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
+            1,   2,    2,   2,   2,  2,    3,  3,   3,   3,
+
+/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
+            3,   0,    0,   0,   1,   1,   1,   1,   2,   2,
+
+/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
+             2,   2,   3,   3,   3,   3,   0,   0,   0,   1,
+
+/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
+             1,   1,   1,   2,   2,   2,   2,   3,  3,   3,
+
+/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
+             0,   0,   0,   1,   1,   1,   1,   2,   2,   2,
+
+/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
+            3,   3,   3,   3,  0,    0,    0,  0,   1,   2,
+
+/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
+            2,   3,   3,    3,  3,   3,   0,   0,   1,   1,
+
+/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
+             2,   4,   4,   5,   6,   7,   7,   0,  0,   3,
+
+};
+
+        static byte[] packet4Zone = new byte[]
+        {
+/*01        Z1  Z2  Z3  Z4  NA  NA  KeyZone */
+            0,  1,  2,  3,  0,  0, 
+
+/*02        RR  R   RM  LM  L   LL  LighBar */
+            7,  7,  6,  5,  4,  4, 
+
+};
+
+
+        public static void ApplyDirect(Color[] color, bool init = false)
+        {
+            const byte keySet = 167;
+            const byte ledCount = 178;
+            const ushort mapSize = 3 * ledCount;
+            const byte ledsPerPacket = 16;
+
+            byte[] buffer = new byte[64];
+            byte[] keyBuf = new byte[mapSize];
+
+            buffer[0] = AsusHid.AURA_ID;
+            buffer[1] = 0xbc;
+            buffer[2] = 0;
+            buffer[3] = 1;
+            buffer[4] = 1;
+            buffer[5] = 1;
+            buffer[6] = 0;
+            buffer[7] = 0x10;
+
+            if (init)
+            {
+                Init();
+                AsusHid.WriteAura(new byte[] { AsusHid.AURA_ID, 0xbc });
+            }
+
+            Array.Clear(keyBuf, 0, keyBuf.Length);
+
+            if (!isStrix4Zone) // per key
+            {
+                for (int ledIndex = 0; ledIndex < packetMap.Count(); ledIndex++)
+                {
+                    ushort offset = (ushort)(3 * packetMap[ledIndex]);
+                    byte zone = packetZone[ledIndex];
+
+                    keyBuf[offset] = color[zone].R;
+                    keyBuf[offset + 1] = color[zone].G;
+                    keyBuf[offset + 2] = color[zone].B;
+                }
+
+                for (int i = 0; i < keySet; i += ledsPerPacket)
+                {
+                    byte ledsRemaining = (byte)(keySet - i);
+
+                    if (ledsRemaining < ledsPerPacket)
+                    {
+                        buffer[7] = ledsRemaining;
+                    }
+
+                    buffer[6] = (byte)i;
+                    Buffer.BlockCopy(keyBuf, 3 * i, buffer, 9, 3 * buffer[7]);
+                    AsusHid.WriteAura(buffer);
+                }
+            }
+
+            buffer[4] = 0x04;
+            buffer[5] = 0x00;
+            buffer[6] = 0x00;
+            buffer[7] = 0x00;
+
+            if (isStrix4Zone) { // per zone
+                var leds_4_zone = packet4Zone.Count();
+                for (int ledIndex = 0; ledIndex < leds_4_zone; ledIndex++)
+                {
+                    byte zone = packet4Zone[ledIndex];
+                    keyBuf[ledIndex * 3] = color[zone].R;
+                    keyBuf[ledIndex * 3 + 1] = color[zone].G;
+                    keyBuf[ledIndex * 3 + 2] = color[zone].B;
+                }
+                Buffer.BlockCopy(keyBuf, 0, buffer, 9, 3 * leds_4_zone);
+                AsusHid.WriteAura(buffer);
+                return;
+            }
+
+            Buffer.BlockCopy(keyBuf, 3 * keySet, buffer, 9, 3 * (ledCount - keySet));
+            AsusHid.WriteAura(buffer);
+        }
+
+
         public static void ApplyColor(Color color, bool init = false)
         {
 
@@ -366,47 +528,8 @@ namespace GHelper.USB
 
             if (isStrix && !isOldHeatmap)
             {
-                byte[] msg = new byte[0x40];
-
-                byte start = 9;
-                byte maxLeds = 0x93;
-
-                msg[0] = AsusHid.AURA_ID;
-                msg[1] = 0xbc;
-                msg[2] = 0;
-                msg[3] = 1;
-                msg[4] = 1;
-                msg[5] = 1;
-                msg[6] = 0;
-                msg[7] = 0x10;
-
-                for (byte i = 0; i < 0x12; i++)
-                {
-                    msg[start + i * 3] = color.R; // R
-                    msg[start + 1 + i * 3] = color.G; // G
-                    msg[start + 2 + i * 3] = color.B; // B
-                }
-
-                if (init)
-                {
-                    Init();
-                    AsusHid.WriteAura(new byte[] { AsusHid.AURA_ID, 0xbc });
-                }
-
-                for (byte b = 0; b < maxLeds; b += 0x10)
-                {
-                    msg[6] = b;
-                    AsusHid.WriteAura(msg);
-                }
-
-                msg[6] = maxLeds;
-                AsusHid.WriteAura(msg);
-
-                msg[4] = 4;
-                msg[5] = 0;
-                msg[6] = 0;
-                msg[7] = 0;
-                AsusHid.WriteAura(msg);
+                ApplyDirect(Enumerable.Repeat(color, AURA_ZONES).ToArray(), init);
+                return;
             }
 
             else
@@ -417,26 +540,6 @@ namespace GHelper.USB
 
         }
 
-
-        public static void ApplyGPUColor()
-        {
-            if ((AuraMode)AppConfig.Get("aura_mode") != AuraMode.GPUMODE) return;
-
-            switch (GPUModeControl.gpuMode)
-            {
-                case AsusACPI.GPUModeUltimate:
-                    ApplyColor(Color.Red, true);
-                    break;
-                case AsusACPI.GPUModeEco:
-                    ApplyColor(Color.Green, true);
-                    break;
-                default:
-                    ApplyColor(Color.Yellow, true);
-                    break;
-            }
-        }
-
-
         public static void ApplyAura()
         {
 
@@ -449,14 +552,23 @@ namespace GHelper.USB
 
             if (Mode == AuraMode.HEATMAP)
             {
-                SetHeatmap(true);
+                CustomRGB.ApplyHeatmap(true);
                 timer.Enabled = true;
+                timer.Interval = 2000;
+                return;
+            }
+
+            if (Mode == AuraMode.AMBIENT)
+            {
+                CustomRGB.ApplyAmbient(true);
+                timer.Enabled = true;
+                timer.Interval = 100;
                 return;
             }
 
             if (Mode == AuraMode.GPUMODE)
             {
-                ApplyGPUColor();
+                CustomRGB.ApplyGPUColor();
                 return;
             }
 
@@ -470,6 +582,212 @@ namespace GHelper.USB
         }
 
 
+        public static class CustomRGB
+        {
+
+            public static void ApplyGPUColor()
+            {
+                if ((AuraMode)AppConfig.Get("aura_mode") != AuraMode.GPUMODE) return;
+
+                switch (GPUModeControl.gpuMode)
+                {
+                    case AsusACPI.GPUModeUltimate:
+                        ApplyColor(Color.Red, true);
+                        break;
+                    case AsusACPI.GPUModeEco:
+                        ApplyColor(Color.Green, true);
+                        break;
+                    default:
+                        ApplyColor(Color.Yellow, true);
+                        break;
+                }
+            }
+
+            public static void ApplyHeatmap(bool init = false)
+            {
+                float cpuTemp = (float)HardwareControl.GetCPUTemp();
+                int freeze = 20, cold = 40, warm = 65, hot = 90;
+                Color color;
+
+                //Debug.WriteLine(cpuTemp);
+
+                if (cpuTemp < cold) color = ColorUtils.GetWeightedAverage(Color.Blue, Color.Green, ((float)cpuTemp - freeze) / (cold - freeze));
+                else if (cpuTemp < warm) color = ColorUtils.GetWeightedAverage(Color.Green, Color.Yellow, ((float)cpuTemp - cold) / (warm - cold));
+                else if (cpuTemp < hot) color = ColorUtils.GetWeightedAverage(Color.Yellow, Color.Red, ((float)cpuTemp - warm) / (hot - warm));
+                else color = Color.Red;
+
+                ApplyColor(color, init);
+            }
+
+
+
+            public static void ApplyAmbient(bool init = false)
+            {
+                var bound = Screen.GetBounds(Point.Empty);
+                bound.Y += bound.Height / 3;
+                bound.Height -= (int)Math.Round(bound.Height * (0.33f + 0.022f)); // cut 1/3 of the top screen + windows panel
+
+                Bitmap screen_low;
+                Bitmap screeb_pxl;
+
+                int zones = AURA_ZONES;
+
+                if (isStrix) // laptop with lightbar
+                {
+                    screen_low = AmbientData.CamptureScreen(bound, 512, 288);   //quality decreases greatly if it is less 512 
+                    screeb_pxl = AmbientData.ResizeImage(screen_low, 4, 2);     // 4x2 zone. top for keyboard and bot for lightbar
+                    var mid_left = ColorUtils.GetMidColor(screeb_pxl.GetPixel(0, 1), screeb_pxl.GetPixel(1, 1));
+                    var mid_right = ColorUtils.GetMidColor(screeb_pxl.GetPixel(2, 1), screeb_pxl.GetPixel(3, 1));
+
+                    AmbientData.Colors[4].RGB = ColorUtils.HSV.UpSaturation(screeb_pxl.GetPixel(1, 1)); // left bck
+                    AmbientData.Colors[5].RGB = ColorUtils.HSV.UpSaturation(mid_left);  // center left
+                    AmbientData.Colors[6].RGB = ColorUtils.HSV.UpSaturation(mid_right); // center right
+                    AmbientData.Colors[7].RGB = ColorUtils.HSV.UpSaturation(screeb_pxl.GetPixel(3, 1)); // right bck
+
+                    for (int i = 0; i < 4; i++) // keyboard
+                        AmbientData.Colors[i].RGB = ColorUtils.HSV.UpSaturation(screeb_pxl.GetPixel(i, 0));
+                }
+                else
+                {
+                    zones = 1;
+                    screen_low = AmbientData.CamptureScreen(bound, 256, 144);
+                    screeb_pxl = AmbientData.ResizeImage(screen_low, 1, 1);
+                    AmbientData.Colors[0].RGB = ColorUtils.HSV.UpSaturation(screeb_pxl.GetPixel(0, 0), (float)0.3);
+                }
+
+
+                //screeb_pxl.Save("test.jpg", ImageFormat.Jpeg);
+                screen_low.Dispose();
+                screeb_pxl.Dispose();
+
+                bool is_fresh = false;
+
+                for (int i = 0; i < zones; i++)
+                {
+                    if (AmbientData.result[i].ToArgb() != AmbientData.Colors[i].RGB.ToArgb()) is_fresh = true;
+                    AmbientData.result[i] = AmbientData.Colors[i].RGB;
+                }
+
+                if (is_fresh)
+                {
+                    if (isStrix) ApplyDirect(AmbientData.result, init);
+                    else ApplyColor(AmbientData.result[0], init);
+                }
+
+            }
+
+            static class AmbientData
+            {
+
+                public enum StretchMode
+                {
+                    STRETCH_ANDSCANS = 1,
+                    STRETCH_ORSCANS = 2,
+                    STRETCH_DELETESCANS = 3,
+                    STRETCH_HALFTONE = 4,
+                }
+
+                [DllImport("user32.dll")]
+                private static extern IntPtr GetDesktopWindow();
+
+                [DllImport("user32.dll")]
+                private static extern IntPtr GetWindowDC(IntPtr hWnd);
+
+                [DllImport("gdi32.dll")]
+                private static extern IntPtr CreateCompatibleDC(IntPtr hDC);
+
+                [DllImport("gdi32.dll")]
+                private static extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int nWidth, int nHeight);
+
+                [DllImport("gdi32.dll")]
+                private static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
+
+                [DllImport("user32.dll")]
+                private static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);
+
+                [DllImport("gdi32.dll")]
+                private static extern bool DeleteDC(IntPtr hdc);
+
+                [DllImport("gdi32.dll")]
+                private static extern bool DeleteObject(IntPtr hObject);
+
+                [DllImport("gdi32.dll")]
+                private static extern bool StretchBlt(IntPtr hdcDest, int nXOriginDest, int nYOriginDest,
+                int nWidthDest, int nHeightDest,
+                IntPtr hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, Int32 dwRop);
+
+                [DllImport("gdi32.dll")]
+                static extern bool SetStretchBltMode(IntPtr hdc, StretchMode iStretchMode);
+
+                /// <summary>
+                /// Captures a screenshot. 
+                /// </summary>
+                public static Bitmap CamptureScreen(Rectangle rec, int out_w, int out_h)
+                {
+                    IntPtr desktop = GetDesktopWindow();
+                    IntPtr hdc = GetWindowDC(desktop);
+                    IntPtr hdcMem = CreateCompatibleDC(hdc);
+
+                    IntPtr hBitmap = CreateCompatibleBitmap(hdc, out_w, out_h);
+                    IntPtr hOld = SelectObject(hdcMem, hBitmap);
+                    SetStretchBltMode(hdcMem, StretchMode.STRETCH_DELETESCANS);
+                    StretchBlt(hdcMem, 0, 0, out_w, out_h, hdc, rec.X, rec.Y, rec.Width, rec.Height, 0x00CC0020);
+                    SelectObject(hdcMem, hOld);
+
+                    DeleteDC(hdcMem);
+                    ReleaseDC(desktop, hdc);
+                    var result = Image.FromHbitmap(hBitmap, IntPtr.Zero);
+                    DeleteObject(hBitmap);
+                    return result;
+                }
+
+                public static Bitmap ResizeImage(Image image, int width, int height)
+                {
+                    var destRect = new Rectangle(0, 0, width, height);
+                    var destImage = new Bitmap(width, height);
+
+                    destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);
+
+                    using (var graphics = Graphics.FromImage(destImage))
+                    {
+                        graphics.CompositingMode = CompositingMode.SourceCopy;
+                        graphics.CompositingQuality = CompositingQuality.HighQuality;
+                        graphics.InterpolationMode = InterpolationMode.Bicubic;
+                        graphics.SmoothingMode = SmoothingMode.None;
+                        graphics.PixelOffsetMode = PixelOffsetMode.None;
+
+                        using (var wrapMode = new ImageAttributes())
+                        {
+                            wrapMode.SetWrapMode(WrapMode.TileFlipXY);
+                            graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode);
+                        }
+                    }
+
+                    return destImage;
+                }
+
+                static public Color[] result = new Color[AURA_ZONES];
+                static public ColorUtils.SmoothColor[] Colors = Enumerable.Repeat(0, AURA_ZONES).
+                    Select(h => new ColorUtils.SmoothColor()).ToArray();
+
+                public static Color GetMostUsedColor(Bitmap bitMap)
+                {
+                    var colorIncidence = new Dictionary<int, int>();
+                    for (var x = 0; x < bitMap.Size.Width; x++)
+                        for (var y = 0; y < bitMap.Size.Height; y++)
+                        {
+                            var pixelColor = bitMap.GetPixel(x, y).ToArgb();
+                            if (colorIncidence.Keys.Contains(pixelColor))
+                                colorIncidence[pixelColor]++;
+                            else
+                                colorIncidence.Add(pixelColor, 1);
+                        }
+                    return Color.FromArgb(colorIncidence.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value).First().Key);
+                }
+            }
+
+        }
+
     }
 
 }

app/USB/XGM.cs

@@ -1,7 +1,6 @@
 // Reference : thanks to https://github.com/RomanYazvinsky/ for initial discovery of XGM payloads
 
 using HidSharp;
-using System.Diagnostics;
 using System.Text;
 
 namespace GHelper.USB
@@ -9,30 +8,37 @@ namespace GHelper.USB
     public static class XGM
     {
         const int XGM_ID = 0x1970;
-        public const int ASUS_ID = 0x0b05;
+        const int ASUS_ID = 0x0b05;
+
         public static void Write(byte[] data)
         {
             HidDeviceLoader loader = new HidDeviceLoader();
-            HidDevice device = loader.GetDevices(ASUS_ID, XGM_ID).Where(device => device.GetMaxFeatureReportLength() >= 300).FirstOrDefault();
-            if (device is null) return;
-
             try
             {
+                HidDevice device = loader.GetDevices(ASUS_ID, XGM_ID).Where(device => device.CanOpen && device.GetMaxFeatureReportLength() >= 300).FirstOrDefault();
+
+                if (device is null)
+                {
+                    Logger.WriteLine("XGM SUB device not found");
+                    return;
+                }
+
                 using (HidStream hidStream = device.Open())
                 {
                     var payload = new byte[300];
                     Array.Copy(data, payload, data.Length);
 
-                    hidStream.Write(payload);
-                    Logger.WriteLine("XGM " + device.ProductID + "|" + device.GetMaxFeatureReportLength() + ":" + BitConverter.ToString(data));
+                    hidStream.SetFeature(payload);
+                    Logger.WriteLine("XGM-" + device.ProductID + "|" + device.GetMaxFeatureReportLength() + ":" + BitConverter.ToString(data));
 
                     hidStream.Close();
                 }
             }
             catch (Exception ex)
             {
-                Debug.WriteLine($"Error accessing HID device: {ex.Message}");
+                Logger.WriteLine($"Error accessing XGM device: {ex}");
             }
+
         }
 
         public static void Init()

docs/README.md

@@ -108,7 +108,9 @@ Ultimate mode is supported (by hardware) only on 2022+ models
 You don't have to, it's purely optional. From my experience built in (in BIOS) performance modes work well. Limit your power or apply custom fan curves only if you have issues. As soon as you click Apply in the ``Fans + Power`` section BIOS will consider your fan curve as "custom"! (no matter if you modified it or not)
 
 #### How does G-helper control my fan speeds?
-**It doesn't.** Your BIOS does (same as in case with Armoury). What G-helper can do - is (optionally) set a custom fan profile to current performance mode consisting of 8 pairs of temperature + fan speed % via same endpoint armoury seem to use.
+**It doesn't.** Your firmware / BIOS controls them in real-time. Armoury also doesn't control fans in real time anyhow.
+
+What G-helper can do - is (optionally) set a custom fan profile to the current performance mode consisting of 8 pairs of temperature + fan speed % via the same endpoint Armoury seems to use. How it will be interpreted - is still up to the firmware.
 
 #### How do I change fan % to fan RPM?
 Click on them
@@ -301,7 +303,7 @@ To disable automatic touchpad toggling when laptop enters / leaves tablet mode
 ```
 
 ### Extra Keybindings 
-- ``Ctrl + Shift + F5`` - Toggle Performance Modes
+- ``Ctrl + Shift + F5`` / ``Ctrl + Shift + Alt + F5``  - Toggle Performance Modes
 - ``Ctrl + Shift + F12`` - Open G-Helper window 
 - ``Ctrl + M1 / M2`` - Screen brightness Down / Up
 - ``Shift + M1 / M2`` - Backlight brightness Down / Up