feat(services): add transition registry and default implementations

feat(cli): implement sensor commands for listing, reading, and watching

feat(cli): create CLI context and router for command handling

feat(plugins): add hardware sensor provider for system metrics

Author: devpossible

src/LCDPossible.Core/Effects/BaseEffect.cs

@@ -0,0 +1,42 @@
+using LCDPossible.Core.Services;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace LCDPossible.Core.Effects;
+
+/// <summary>
+/// Abstract base class for visual post-processing effects.
+/// </summary>
+public abstract class BaseEffect : IVisualEffect
+{
+    /// <inheritdoc />
+    public abstract string EffectId { get; }
+
+    /// <inheritdoc />
+    public abstract string DisplayName { get; }
+
+    /// <inheritdoc />
+    public bool IsEnabled { get; set; } = true;
+
+    /// <inheritdoc />
+    public float Intensity { get; set; } = 1.0f;
+
+    /// <inheritdoc />
+    public abstract void Apply(Image<Rgba32> image);
+
+    /// <summary>
+    /// Linear interpolation between two values based on intensity.
+    /// </summary>
+    protected float Lerp(float a, float b, float t) => a + (b - a) * t;
+
+    /// <summary>
+    /// Clamps a value between 0 and 255.
+    /// </summary>
+    protected byte ClampByte(float value) => (byte)Math.Clamp(value, 0, 255);
+
+    /// <inheritdoc />
+    public virtual void Dispose()
+    {
+        GC.SuppressFinalize(this);
+    }
+}

src/LCDPossible.Core/Effects/ColorTintEffect.cs

@@ -0,0 +1,80 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace LCDPossible.Core.Effects;
+
+/// <summary>
+/// Applies a color tint/overlay to the image.
+/// </summary>
+public sealed class ColorTintEffect : BaseEffect
+{
+    /// <inheritdoc />
+    public override string EffectId => "color-tint";
+
+    /// <inheritdoc />
+    public override string DisplayName => "Color Tint";
+
+    /// <summary>
+    /// The tint color. Default is cyan (0, 212, 255).
+    /// </summary>
+    public Rgba32 TintColor { get; set; } = new(0, 212, 255);
+
+    /// <summary>
+    /// Blend mode: "multiply", "overlay", or "screen". Default is "multiply".
+    /// </summary>
+    public string BlendMode { get; set; } = "multiply";
+
+    /// <inheritdoc />
+    public override void Apply(Image<Rgba32> image)
+    {
+        if (!IsEnabled || Intensity <= 0) return;
+
+        var tintR = TintColor.R / 255f;
+        var tintG = TintColor.G / 255f;
+        var tintB = TintColor.B / 255f;
+
+        image.ProcessPixelRows(accessor =>
+        {
+            for (var y = 0; y < accessor.Height; y++)
+            {
+                var row = accessor.GetRowSpan(y);
+                for (var x = 0; x < row.Length; x++)
+                {
+                    ref var pixel = ref row[x];
+                    var r = pixel.R / 255f;
+                    var g = pixel.G / 255f;
+                    var b = pixel.B / 255f;
+
+                    float newR, newG, newB;
+
+                    switch (BlendMode.ToLowerInvariant())
+                    {
+                        case "screen":
+                            newR = 1 - (1 - r) * (1 - tintR);
+                            newG = 1 - (1 - g) * (1 - tintG);
+                            newB = 1 - (1 - b) * (1 - tintB);
+                            break;
+
+                        case "overlay":
+                            newR = r < 0.5f ? 2 * r * tintR : 1 - 2 * (1 - r) * (1 - tintR);
+                            newG = g < 0.5f ? 2 * g * tintG : 1 - 2 * (1 - g) * (1 - tintG);
+                            newB = b < 0.5f ? 2 * b * tintB : 1 - 2 * (1 - b) * (1 - tintB);
+                            break;
+
+                        case "multiply":
+                        default:
+                            newR = r * tintR;
+                            newG = g * tintG;
+                            newB = b * tintB;
+                            break;
+                    }
+
+                    // Blend with original based on intensity
+                    pixel.R = ClampByte(Lerp(pixel.R, newR * 255f, Intensity));
+                    pixel.G = ClampByte(Lerp(pixel.G, newG * 255f, Intensity));
+                    pixel.B = ClampByte(Lerp(pixel.B, newB * 255f, Intensity));
+                }
+            }
+        });
+    }
+}

src/LCDPossible.Core/Effects/EffectRegistry.cs

@@ -0,0 +1,115 @@
+using LCDPossible.Core.Services;
+
+namespace LCDPossible.Core.Effects;
+
+/// <summary>
+/// Default implementation of the effect registry with built-in effects.
+/// </summary>
+public sealed class EffectRegistry : IEffectRegistry, IDisposable
+{
+    private readonly Dictionary<string, Func<IVisualEffect>> _effectFactories = new(StringComparer.OrdinalIgnoreCase);
+    private readonly List<IVisualEffect> _activeEffects = [];
+    private bool _disposed;
+
+    /// <summary>
+    /// Creates a new effect registry with built-in effects registered.
+    /// </summary>
+    public EffectRegistry()
+    {
+        // Register built-in effects
+        RegisterEffect("vignette", () => new VignetteEffect());
+        RegisterEffect("scanlines", () => new ScanlinesEffect());
+        RegisterEffect("noise", () => new NoiseEffect());
+        RegisterEffect("glow", () => new GlowEffect());
+        RegisterEffect("color-tint", () => new ColorTintEffect());
+    }
+
+    /// <summary>
+    /// Registers an effect factory.
+    /// </summary>
+    /// <param name="effectId">Unique effect identifier.</param>
+    /// <param name="factory">Factory function to create effect instances.</param>
+    public void RegisterEffect(string effectId, Func<IVisualEffect> factory)
+    {
+        _effectFactories[effectId] = factory;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<EffectTypeInfo> GetEffectTypes()
+    {
+        var types = new List<EffectTypeInfo>();
+
+        foreach (var (id, factory) in _effectFactories)
+        {
+            using var effect = factory();
+            types.Add(new EffectTypeInfo(id, effect.DisplayName));
+        }
+
+        return types;
+    }
+
+    /// <inheritdoc />
+    public IVisualEffect? CreateEffect(string effectId)
+    {
+        return _effectFactories.TryGetValue(effectId, out var factory) ? factory() : null;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<IVisualEffect> ActiveEffects => _activeEffects.AsReadOnly();
+
+    /// <inheritdoc />
+    public void AddEffect(string effectId)
+    {
+        var effect = CreateEffect(effectId);
+        if (effect != null)
+        {
+            _activeEffects.Add(effect);
+        }
+    }
+
+    /// <inheritdoc />
+    public void RemoveEffect(string effectId)
+    {
+        var effect = _activeEffects.FirstOrDefault(e => e.EffectId.Equals(effectId, StringComparison.OrdinalIgnoreCase));
+        if (effect != null)
+        {
+            _activeEffects.Remove(effect);
+            effect.Dispose();
+        }
+    }
+
+    /// <inheritdoc />
+    public void ClearEffects()
+    {
+        foreach (var effect in _activeEffects)
+        {
+            effect.Dispose();
+        }
+        _activeEffects.Clear();
+    }
+
+    /// <summary>
+    /// Applies all active effects to an image in order.
+    /// </summary>
+    /// <param name="image">The image to apply effects to.</param>
+    public void ApplyAll(SixLabors.ImageSharp.Image<SixLabors.ImageSharp.PixelFormats.Rgba32> image)
+    {
+        foreach (var effect in _activeEffects)
+        {
+            if (effect.IsEnabled)
+            {
+                effect.Apply(image);
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+
+        ClearEffects();
+        GC.SuppressFinalize(this);
+    }
+}

src/LCDPossible.Core/Effects/GlowEffect.cs

@@ -0,0 +1,79 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+
+namespace LCDPossible.Core.Effects;
+
+/// <summary>
+/// Applies a bloom/glow effect to bright areas of the image.
+/// </summary>
+public sealed class GlowEffect : BaseEffect
+{
+    /// <inheritdoc />
+    public override string EffectId => "glow";
+
+    /// <inheritdoc />
+    public override string DisplayName => "Glow";
+
+    /// <summary>
+    /// Blur radius for the glow effect. Default is 10.
+    /// </summary>
+    public float BlurRadius { get; set; } = 10f;
+
+    /// <summary>
+    /// Brightness threshold for glow (0-255). Pixels brighter than this will glow. Default is 180.
+    /// </summary>
+    public byte Threshold { get; set; } = 180;
+
+    /// <inheritdoc />
+    public override void Apply(Image<Rgba32> image)
+    {
+        if (!IsEnabled || Intensity <= 0) return;
+
+        // Create a copy for the glow layer
+        using var glowLayer = image.Clone();
+
+        // Extract bright areas
+        glowLayer.ProcessPixelRows(accessor =>
+        {
+            for (var y = 0; y < accessor.Height; y++)
+            {
+                var row = accessor.GetRowSpan(y);
+                for (var x = 0; x < row.Length; x++)
+                {
+                    ref var pixel = ref row[x];
+                    var brightness = (pixel.R + pixel.G + pixel.B) / 3;
+
+                    if (brightness < Threshold)
+                    {
+                        pixel = new Rgba32(0, 0, 0, 0);
+                    }
+                }
+            }
+        });
+
+        // Apply blur to the glow layer
+        glowLayer.Mutate(ctx => ctx.GaussianBlur(BlurRadius * Intensity));
+
+        // Blend the glow layer back onto the original using additive blending
+        image.ProcessPixelRows(glowLayer, (originalAccessor, glowAccessor) =>
+        {
+            for (var y = 0; y < originalAccessor.Height; y++)
+            {
+                var originalRow = originalAccessor.GetRowSpan(y);
+                var glowRow = glowAccessor.GetRowSpan(y);
+
+                for (var x = 0; x < originalRow.Length; x++)
+                {
+                    ref var original = ref originalRow[x];
+                    var glow = glowRow[x];
+
+                    // Additive blend with intensity
+                    original.R = ClampByte(original.R + glow.R * Intensity);
+                    original.G = ClampByte(original.G + glow.G * Intensity);
+                    original.B = ClampByte(original.B + glow.B * Intensity);
+                }
+            }
+        });
+    }
+}

src/LCDPossible.Core/Effects/NoiseEffect.cs

@@ -0,0 +1,62 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace LCDPossible.Core.Effects;
+
+/// <summary>
+/// Applies film grain/noise effect to the image.
+/// </summary>
+public sealed class NoiseEffect : BaseEffect
+{
+    private readonly Random _random = new();
+
+    /// <inheritdoc />
+    public override string EffectId => "noise";
+
+    /// <inheritdoc />
+    public override string DisplayName => "Film Grain";
+
+    /// <summary>
+    /// Amount of noise to apply (0.0 to 1.0). Default is 0.1.
+    /// </summary>
+    public float Amount { get; set; } = 0.1f;
+
+    /// <summary>
+    /// Whether to use monochrome noise (true) or color noise (false). Default is true.
+    /// </summary>
+    public bool Monochrome { get; set; } = true;
+
+    /// <inheritdoc />
+    public override void Apply(Image<Rgba32> image)
+    {
+        if (!IsEnabled || Intensity <= 0) return;
+
+        var effectiveAmount = Amount * Intensity * 255f;
+
+        image.ProcessPixelRows(accessor =>
+        {
+            for (var y = 0; y < accessor.Height; y++)
+            {
+                var row = accessor.GetRowSpan(y);
+                for (var x = 0; x < row.Length; x++)
+                {
+                    ref var pixel = ref row[x];
+
+                    if (Monochrome)
+                    {
+                        var noise = (float)(_random.NextDouble() * 2 - 1) * effectiveAmount;
+                        pixel.R = ClampByte(pixel.R + noise);
+                        pixel.G = ClampByte(pixel.G + noise);
+                        pixel.B = ClampByte(pixel.B + noise);
+                    }
+                    else
+                    {
+                        pixel.R = ClampByte(pixel.R + (float)(_random.NextDouble() * 2 - 1) * effectiveAmount);
+                        pixel.G = ClampByte(pixel.G + (float)(_random.NextDouble() * 2 - 1) * effectiveAmount);
+                        pixel.B = ClampByte(pixel.B + (float)(_random.NextDouble() * 2 - 1) * effectiveAmount);
+                    }
+                }
+            }
+        });
+    }
+}