fix: RGB Direct mode switching + overlay transparency crash + per-frame cache

RGB — the root cause of colours not reaching hardware:

- Auto-switch all OpenRGB devices to Direct/Custom mode on connect

- Without this, devices stay in Rainbow/Spectrum effects and ignore UpdateLeds()

- Cache device layout in SetDeviceColorAsync/SetAllDevicesColorAsync

- Eliminates per-frame GetAllControllerData() SDK round-trip (was 30x/sec)

- Surface ModeSwitchStatus in IRgbService for UI feedback

Overlay — AcrylicBlur is broken on Windows 11:

- Replace AcrylicBlur with plain Transparent + alpha background

- Add TransparencyBackgroundFallback to prevent ghost rendering

- Fix double-alpha stacking (AXAML was semi-transparent + code-behind alpha)

- Opaque mode now fully solid, no blur artifacts

Author: AntwerpDesignsIonity

src/Fanzi.FanControl/Services/DirectRgbController.cs

@@ -22,6 +22,7 @@ public sealed class DirectRgbController : IRgbService, IDisposable
 
     public bool IsConnected => _virtualDevices.Count > 0 || (_bridge?.IsConnected ?? false);
     public string ServerVersion => _bridge?.ServerVersion ?? "IO-nity Direct RGB Engine v2.0";
+    public string ModeSwitchStatus => _bridge?.ModeSwitchStatus ?? "Virtual devices (no mode switch needed)";
 
     public IReadOnlyList<VirtualRgbDevice> VirtualDevices => _virtualDevices;
 

src/Fanzi.FanControl/Services/IRgbService.cs

@@ -18,6 +18,12 @@ public interface IRgbService : IDisposable
     /// <summary>Server version string returned after handshake.</summary>
     string ServerVersion { get; }
 
+    /// <summary>
+    /// Summary of the last mode-switch pass (e.g. "3 switched to Direct, 1 already Direct").
+    /// Empty string if no mode switching has occurred yet.
+    /// </summary>
+    string ModeSwitchStatus { get; }
+
     /// <summary>
     /// Attempts to connect to the OpenRGB server.
     /// Returns true on success; false if server is not reachable.

src/Fanzi.FanControl/Services/OpenRgbService.cs

@@ -10,19 +10,26 @@ namespace Fanzi.FanControl.Services;
 
 /// <summary>
 /// OpenRGB-backed implementation of <see cref="IRgbService"/>.
-/// Requires the OpenRGB application to be running with its SDK server enabled
-/// (Settings → SDK Server, default port 6742).
+/// Connects to the OpenRGB SDK server (default port 6742), auto-switches all
+/// discovered devices to Direct/Custom mode so per-LED colours actually reach hardware,
+/// and caches the device layout to avoid per-frame SDK round-trips.
 /// </summary>
 public sealed class OpenRgbService : IRgbService
 {
     private OpenRgbClient?      _client;
-    private OpenRGB.NET.Device[]? _deviceCache;   // zone/LED layout, refreshed on each device scan
+    private OpenRGB.NET.Device[]? _deviceCache;
     private bool                _disposed;
     private readonly object     _lock = new();
 
     public bool   IsConnected   { get; private set; }
     public string ServerVersion { get; private set; } = "Not connected";
 
+    /// <summary>
+    /// Summary of the last mode-switch pass — surfaced in the UI so users can see
+    /// which devices were switched to Direct mode and which (if any) failed.
+    /// </summary>
+    public string ModeSwitchStatus { get; private set; } = "";
+
     // ── Connection ────────────────────────────────────────────────────────────
 
     public Task<bool> TryConnectAsync(
@@ -42,6 +49,7 @@ public Task<bool> TryConnectAsync(
                     _deviceCache = null;
                     IsConnected   = false;
                     ServerVersion = "Not connected";
+                    ModeSwitchStatus = "";
 
                     var client = new OpenRgbClient(
                         ip:                     host,
@@ -75,6 +83,7 @@ public void Disconnect()
             _deviceCache  = null;
             IsConnected   = false;
             ServerVersion = "Disconnected";
+            ModeSwitchStatus = "";
         }
     }
 
@@ -93,7 +102,13 @@ public Task<IReadOnlyList<RgbDeviceInfo>> GetDevicesAsync(
                 try
                 {
                     var devices = _client.GetAllControllerData();
-                    _deviceCache = devices;   // cache layout so per-zone sends don't round-trip each frame
+                    _deviceCache = devices;
+
+                    // Auto-switch every device to Direct/Custom mode so per-LED
+                    // colour updates actually reach the hardware.  Without this,
+                    // devices stay in their built-in effect (Rainbow, Spectrum,
+                    // etc.) and silently ignore UpdateLeds() calls.
+                    SwitchAllDevicesToDirectMode(devices);
 
                     return devices
                         .Select((d, i) =>
@@ -119,15 +134,87 @@ public Task<IReadOnlyList<RgbDeviceInfo>> GetDevicesAsync(
                         })
                         .ToArray();
                 }
-                catch
+                catch (Exception ex)
                 {
+                    ServerVersion = $"Error: {ex.Message.Split('\n')[0]}";
                     IsConnected = false;
                     return Array.Empty<RgbDeviceInfo>();
                 }
             }
         }, cancellationToken);
     }
 
+    /// <summary>
+    /// Iterates every discovered device and switches it to "Direct" or "Custom"
+    /// mode — the mode that lets FANZI drive each LED individually.
+    /// Devices already in Direct mode are left alone.
+    /// </summary>
+    private void SwitchAllDevicesToDirectMode(OpenRGB.NET.Device[] devices)
+    {
+        int switched = 0, already = 0, failed = 0;
+
+        for (int i = 0; i < devices.Length; i++)
+        {
+            try
+            {
+                var dev = devices[i];
+                var activeMode = dev.ActiveMode;
+
+                // Already in Direct/Custom/Static-per-LED? Nothing to do.
+                string modeName = activeMode.Name ?? "";
+                bool isDirect = modeName.Contains("Direct", StringComparison.OrdinalIgnoreCase)
+                             || modeName.Contains("Custom", StringComparison.OrdinalIgnoreCase)
+                             || modeName.Contains("Static", StringComparison.OrdinalIgnoreCase);
+
+                if (isDirect)
+                {
+                    already++;
+                    continue;
+                }
+
+                // Find the Direct or Custom mode index on this device.
+                int directIndex = -1;
+                for (int m = 0; m < dev.Modes.Length; m++)
+                {
+                    string name = dev.Modes[m].Name ?? "";
+                    if (name.Equals("Direct", StringComparison.OrdinalIgnoreCase)
+                     || name.Equals("Custom", StringComparison.OrdinalIgnoreCase))
+                    {
+                        directIndex = m;
+                        break;
+                    }
+                }
+
+                // Prefer "Direct" — if not found, try "Custom" via SetCustomMode.
+                if (directIndex >= 0)
+                {
+                    _client!.UpdateMode(i, directIndex);
+                    switched++;
+                }
+                else
+                {
+                    // SetCustomMode sends the RGBController::SetCustomMode() command
+                    // which on most devices activates the per-LED direct control path.
+                    _client!.SetCustomMode(i);
+                    switched++;
+                }
+            }
+            catch
+            {
+                failed++;
+            }
+        }
+
+        var parts = new List<string>();
+        if (switched > 0) parts.Add($"{switched} switched to Direct");
+        if (already > 0)  parts.Add($"{already} already Direct");
+        if (failed > 0)   parts.Add($"{failed} failed");
+
+        ModeSwitchStatus = parts.Count > 0
+            ? string.Join(", ", parts)
+            : "No devices";
+    }
+
     // ── Colour setting ────────────────────────────────────────────────────────
 
     public Task SetDeviceColorAsync(
@@ -143,7 +230,8 @@ public Task SetDeviceColorAsync(
                 if (_client is null || !IsConnected) return;
                 try
                 {
-                    var devices = _client.GetAllControllerData();
+                    // Use cached device layout — avoids a full SDK round-trip every frame.
+                    var devices = _deviceCache ?? _client.GetAllControllerData();
                     if (deviceIndex < 0 || deviceIndex >= devices.Length) return;
 
                     int count  = devices[deviceIndex].Leds.Length;
@@ -188,11 +276,13 @@ public Task SetAllDevicesColorAsync(
                 if (_client is null || !IsConnected) return;
                 try
                 {
-                    var devices = _client.GetAllControllerData();
+                    // Use cached device layout — critical for performance.
+                    var devices = _deviceCache ?? _client.GetAllControllerData();
+                    var openColor = ToOpenRgb(color);
                     for (int i = 0; i < devices.Length; i++)
                     {
                         var colors = Enumerable
-                            .Repeat(ToOpenRgb(color), devices[i].Leds.Length)
+                            .Repeat(openColor, devices[i].Leds.Length)
                             .ToArray();
                         _client.UpdateLeds(i, colors);
                     }
@@ -215,16 +305,12 @@ public Task SetDeviceZoneColorsAsync(
                 if (_client is null || !IsConnected) return;
                 try
                 {
-                    // Use the cached layout where possible so we don't hit the SDK every frame.
                     var devices = _deviceCache ?? _client.GetAllControllerData();
                     if (deviceIndex < 0 || deviceIndex >= devices.Length) return;
 
                     var dev = devices[deviceIndex];
                     int ledTotal = dev.Leds.Length;
 
-                    // Build the full per-LED buffer for the device, expanding each zone's
-                    // colour across its LED span. Pre-fill black so unzoned/trailing LEDs
-                    // are always initialised (safe whether Color is a struct or class).
                     var black = ToOpenRgb(RgbColor.Black);
                     var leds  = new OpenRGB.NET.Color[ledTotal];
                     for (int k = 0; k < ledTotal; k++) leds[k] = black;

src/Fanzi.FanControl/Views/MiniOverlayWindow.axaml

@@ -9,7 +9,9 @@
         ShowInTaskbar="False"
         CanResize="False"
         SystemDecorations="None"
-        Background="#CC050A12"
+        Background="#080E18"
+        TransparencyLevelHint="Transparent"
+        TransparencyBackgroundFallback="#050A12"
         WindowStartupLocation="Manual">
 
     <Window.Styles>

src/Fanzi.FanControl/Views/MiniOverlayWindow.axaml.cs

@@ -29,7 +29,6 @@ public MiniOverlayWindow()
         var closeBtn = this.FindControl<Button>("CloseBtn");
         if (closeBtn is not null) closeBtn.Click += (_, _) => Hide();
 
-        // Apply transparency from settings when DataContext is set
         DataContextChanged += OnDataContextChanged;
     }
 
@@ -40,7 +39,6 @@ private void OnDataContextChanged(object? sender, EventArgs e)
             _vm = vm;
             ApplyTransparency();
 
-            // Listen for changes
             vm.PropertyChanged += (s, args) =>
             {
                 if (args.PropertyName == nameof(MainWindowViewModel.OverlayTransparent) ||
@@ -56,17 +54,21 @@ private void ApplyTransparency()
     {
         if (_vm is null) return;
 
+        byte alpha = (byte)(Math.Clamp(_vm.OverlayOpacity, 0.1, 1.0) * 255);
+
         if (_vm.OverlayTransparent)
         {
-            // Transparent mode: acrylic blur + semi-transparent background
-            TransparencyLevelHint = new[] { Avalonia.Controls.WindowTransparencyLevel.AcrylicBlur };
-            byte alpha = (byte)(Math.Clamp(_vm.OverlayOpacity, 0.1, 1.0) * 255);
+            // Use solid colour with alpha — avoids AcrylicBlur which is broken
+            // on many Windows 11 builds (flickering, garbage pixels, ghost windows).
+            TransparencyLevelHint = new[] { WindowTransparencyLevel.Transparent };
+            TransparencyBackgroundFallback = new SolidColorBrush(Color.FromArgb(255, 5, 10, 18));
             Background = new SolidColorBrush(Color.FromArgb(alpha, 5, 10, 18));
         }
         else
         {
-            // Opaque mode: solid dark background, no blur
-            TransparencyLevelHint = new[] { Avalonia.Controls.WindowTransparencyLevel.None };
+            // Fully opaque — no transparency at all.
+            TransparencyLevelHint = new[] { WindowTransparencyLevel.None };
+            TransparencyBackgroundFallback = new SolidColorBrush(Color.FromArgb(255, 8, 14, 24));
             Background = new SolidColorBrush(Color.FromArgb(255, 8, 14, 24));
         }
     }