Reworked rendering

RGB.NET.Presets/Textures/AbstractGradientTexture.cs

@@ -0,0 +1,42 @@
+using RGB.NET.Core;
+using RGB.NET.Presets.Textures.Gradients;
+
+namespace RGB.NET.Presets.Textures
+{
+    public abstract class AbstractGradientTexture : AbstractBindable, ITexture
+    {
+        #region Properties & Fields
+
+        /// <summary>
+        /// Gets the gradient drawn by the brush.
+        /// </summary>
+        public IGradient Gradient { get; }
+
+        /// <inheritdoc />
+        public Size Size { get; }
+
+        /// <inheritdoc />
+        public Color this[in Point point] => GetColor(point);
+
+        /// <inheritdoc />
+        public Color this[in Rectangle rectangle] => GetColor(rectangle.Center);
+
+        #endregion
+
+        #region Constructors
+
+        protected AbstractGradientTexture(Size size, IGradient gradient)
+        {
+            this.Size = size;
+            this.Gradient = gradient;
+        }
+
+        #endregion
+
+        #region Methods
+
+        protected abstract Color GetColor(in Point point);
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/ConicalGradientTexture.cs

@@ -0,0 +1,98 @@
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable ReturnTypeCanBeEnumerable.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable UnusedMember.Global
+
+using System;
+using RGB.NET.Core;
+using RGB.NET.Presets.Textures.Gradients;
+
+namespace RGB.NET.Presets.Textures
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Represents a brush drawing a conical gradient.
+    /// </summary>
+    public sealed class ConicalGradientTexture : AbstractGradientTexture
+    {
+        #region Constants
+
+        private const double PI2 = Math.PI * 2;
+
+        #endregion
+
+        #region Properties & Fields
+
+        private double _origin = Math.Atan2(-1, 0);
+        /// <summary>
+        /// Gets or sets the origin (radian-angle) this <see cref="ConicalGradientTexture"/> is drawn to. (default: -π/2)
+        /// </summary>
+        public double Origin
+        {
+            get => _origin;
+            set => SetProperty(ref _origin, value);
+        }
+
+        private Point _center = new(0.5, 0.5);
+        /// <summary>
+        /// Gets or sets the center <see cref="Point"/> (as percentage in the range [0..1]) of the <see cref="IGradient"/> drawn by this <see cref="ConicalGradientTexture"/>. (default: 0.5, 0.5)
+        /// </summary>
+        public Point Center
+        {
+            get => _center;
+            set => SetProperty(ref _center, value);
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" /> class.
+        /// </summary>
+        /// <param name="gradient">The <see cref="T:RGB.NET.Presets.Gradients.IGradient" /> drawn by this <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" />.</param>
+        public ConicalGradientTexture(Size size, IGradient gradient)
+            : base(size, gradient)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" /> class.
+        /// </summary>
+        /// <param name="center">The center <see cref="T:RGB.NET.Core.Point" /> (as percentage in the range [0..1]).</param>
+        /// <param name="gradient">The <see cref="T:RGB.NET.Presets.Gradients.IGradient" /> drawn by this <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" />.</param>
+        public ConicalGradientTexture(Size size, IGradient gradient, Point center)
+            : base(size, gradient)
+        {
+            this.Center = center;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" /> class.
+        /// </summary>
+        /// <param name="center">The center <see cref="T:RGB.NET.Core.Point" /> (as percentage in the range [0..1]).</param>
+        /// <param name="origin">The origin (radian-angle) the <see cref="T:RGB.NET.Core.IBrush" /> is drawn to.</param>
+        /// <param name="gradient">The <see cref="T:RGB.NET.Presets.Gradients.IGradient" /> drawn by this <see cref="T:RGB.NET.Presets.Textures.ConicalGradientTexture" />.</param>
+        public ConicalGradientTexture(Size size, IGradient gradient, Point center, float origin)
+            : base(size, gradient)
+        {
+            this.Center = center;
+            this.Origin = origin;
+        }
+
+        #endregion
+
+        #region Methods
+
+        protected override Color GetColor(in Point point)
+        {
+            double angle = Math.Atan2(point.Y - Center.Y, point.X - Center.X) - Origin;
+            if (angle < 0) angle += PI2;
+            double offset = angle / PI2;
+
+            return Gradient.GetColor(offset);
+        }
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/Gradients/AbstractGradient.cs

@@ -0,0 +1,151 @@
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Linq;
+using RGB.NET.Core;
+using RGB.NET.Presets.Decorators;
+
+namespace RGB.NET.Presets.Textures.Gradients
+{
+    /// <inheritdoc cref="AbstractDecoratable{T}" />
+    /// <inheritdoc cref="IGradient" />
+    /// <summary>
+    /// Represents a basic gradient.
+    /// </summary>
+    public abstract class AbstractGradient : AbstractDecoratable<IGradientDecorator>, IGradient
+    {
+        #region Properties & Fields
+
+        /// <summary>
+        /// Gets a list of the stops used by this <see cref="AbstractGradient"/>.
+        /// </summary>
+        public ObservableCollection<GradientStop> GradientStops { get; } = new();
+
+        private bool _wrapGradient;
+        /// <summary>
+        /// Gets or sets if the Gradient wraps around if there isn't a second stop to take.
+        /// Example: There is a stop at offset 0.0, 0.5 and 0.75. 
+        /// Without wrapping offset 1.0 will be calculated the same as 0.75; with wrapping it would be the same as 0.0.
+        /// </summary>
+        public bool WrapGradient
+        {
+            get => _wrapGradient;
+            set => SetProperty(ref _wrapGradient, value);
+        }
+
+        #endregion
+
+        #region Events
+
+        /// <inheritdoc />
+        public event EventHandler? GradientChanged;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AbstractGradient"/> class.
+        /// </summary>
+        protected AbstractGradient()
+        {
+            GradientStops.CollectionChanged += GradientCollectionChanged;
+            PropertyChanged += (_, _) => OnGradientChanged();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AbstractGradient"/> class.
+        /// </summary>
+        /// <param name="gradientStops">The stops with which the gradient should be initialized.</param>
+        protected AbstractGradient(params GradientStop[] gradientStops)
+        {
+            GradientStops.CollectionChanged += GradientCollectionChanged;
+            PropertyChanged += (_, _) => OnGradientChanged();
+
+            foreach (GradientStop gradientStop in gradientStops)
+                GradientStops.Add(gradientStop);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AbstractGradient"/> class.
+        /// </summary>
+        /// <param name="wrapGradient">Specifies whether the gradient should wrapp or not (see <see cref="WrapGradient"/> for an example of what this means).</param>
+        /// <param name="gradientStops">The stops with which the gradient should be initialized.</param>
+        protected AbstractGradient(bool wrapGradient, params GradientStop[] gradientStops)
+        {
+            this.WrapGradient = wrapGradient;
+
+            GradientStops.CollectionChanged += GradientCollectionChanged;
+            PropertyChanged += (_, _) => OnGradientChanged();
+
+            foreach (GradientStop gradientStop in gradientStops)
+                GradientStops.Add(gradientStop);
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Clips the offset and ensures, that it is inside the bounds of the stop list.
+        /// </summary>
+        /// <param name="offset"></param>
+        /// <returns></returns>
+        protected double ClipOffset(double offset)
+        {
+            double max = GradientStops.Max(stop => stop.Offset);
+            if (offset > max)
+                return max;
+
+            double min = GradientStops.Min(stop => stop.Offset);
+            return offset < min ? min : offset;
+        }
+
+        /// <inheritdoc />
+        public abstract Color GetColor(double offset);
+
+        /// <inheritdoc />
+        public virtual void Move(double offset)
+        {
+            offset /= 360.0;
+
+            foreach (GradientStop gradientStop in GradientStops)
+                gradientStop.Offset += offset;
+
+            while (GradientStops.All(stop => stop.Offset > 1))
+                foreach (GradientStop gradientStop in GradientStops)
+                    gradientStop.Offset -= 1;
+
+            while (GradientStops.All(stop => stop.Offset < 0))
+                foreach (GradientStop gradientStop in GradientStops)
+                    gradientStop.Offset += 1;
+        }
+
+        /// <summary>
+        /// Should be called to indicate that the gradient was changed.
+        /// </summary>
+        protected void OnGradientChanged() => GradientChanged?.Invoke(this, EventArgs.Empty);
+
+        private void GradientCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (e.OldItems != null)
+                foreach (GradientStop gradientStop in e.OldItems)
+                    gradientStop.PropertyChanged -= GradientStopChanged;
+
+            if (e.NewItems != null)
+                foreach (GradientStop gradientStop in e.NewItems)
+                    gradientStop.PropertyChanged += GradientStopChanged;
+
+            OnGradientChanged();
+        }
+
+        private void GradientStopChanged(object? sender, PropertyChangedEventArgs propertyChangedEventArgs) => OnGradientChanged();
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/Gradients/GradientStop.cs

@@ -0,0 +1,52 @@
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable MemberCanBePrivate.Global
+
+using RGB.NET.Core;
+
+namespace RGB.NET.Presets.Textures.Gradients
+{
+    /// <summary>
+    /// Represents a stop on a gradient.
+    /// </summary>
+    public class GradientStop : AbstractBindable
+    {
+        #region Properties & Fields
+
+        private double _offset;
+        /// <summary>
+        /// Gets or sets the percentage offset to place this <see cref="GradientStop"/>. This should be inside the range of [0..1] but it's not necessary.
+        /// </summary>
+        public double Offset
+        {
+            get => _offset;
+            set => SetProperty(ref _offset, value);
+        }
+
+        private Color _color;
+        /// <summary>
+        /// Gets or sets the <see cref="Color"/> of this <see cref="GradientStop"/>.
+        /// </summary>
+        public Color Color
+        {
+            get => _color;
+            set => SetProperty(ref _color, value);
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GradientStop"/> class.
+        /// </summary>
+        /// <param name="offset">The percentage offset to place this <see cref="GradientStop"/>.</param>
+        /// <param name="color">The <see cref="Color"/> of the <see cref="GradientStop"/>.</param>
+        public GradientStop(double offset, Color color)
+        {
+            this.Offset = offset;
+            this.Color = color;
+        }
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/Gradients/IGradient.cs

@@ -0,0 +1,30 @@
+using System;
+using RGB.NET.Core;
+using RGB.NET.Presets.Decorators;
+
+namespace RGB.NET.Presets.Textures.Gradients
+{
+    /// <summary>
+    /// Represents a basic gradient.
+    /// </summary>
+    public interface IGradient : IDecoratable<IGradientDecorator>
+    {
+        /// <summary>
+        /// Occurs if the <see cref="IGradient"/> is changed.
+        /// </summary>
+        event EventHandler GradientChanged;
+
+        /// <summary>
+        /// Gets the <see cref="Color"/> of the <see cref="IGradient"/> on the specified offset.
+        /// </summary>
+        /// <param name="offset">The percentage offset to take the <see cref="Color"/> from.</param>
+        /// <returns>The <see cref="Color"/> at the specific offset.</returns>
+        Color GetColor(double offset);
+
+        /// <summary>
+        /// Moves the <see cref="IGradient"/> by the provided offset.
+        /// </summary>
+        /// <param name="offset">The offset the <see cref="IGradient"/> should be moved.</param>
+        void Move(double offset);
+    }
+}

RGB.NET.Presets/Textures/Gradients/LinearGradient.cs

@@ -0,0 +1,152 @@
+// ReSharper disable UnusedMember.Global
+
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using RGB.NET.Core;
+
+namespace RGB.NET.Presets.Textures.Gradients
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Represents a linear interpolated gradient with n stops.
+    /// </summary>
+    public class LinearGradient : AbstractGradient
+    {
+        #region Properties & Fields
+
+        private bool _isOrderedGradientListDirty = true;
+        private LinkedList<GradientStop> _orderedGradientStops = new();
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.Gradients.LinearGradient" /> class.
+        /// </summary>
+        public LinearGradient()
+        {
+            Initialize();
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.Gradients.LinearGradient" /> class.
+        /// </summary>
+        /// <param name="gradientStops">The stops with which the gradient should be initialized.</param>
+        public LinearGradient(params GradientStop[] gradientStops)
+            : base(gradientStops)
+        {
+            Initialize();
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.Gradients.AbstractGradient" /> class.
+        /// </summary>
+        /// <param name="wrapGradient">Specifies whether the gradient should wrapp or not (see <see cref="P:RGB.NET.Presets.Textures.Gradients.AbstractGradient.WrapGradient" /> for an example of what this means).</param>
+        /// <param name="gradientStops">The stops with which the gradient should be initialized.</param>
+        public LinearGradient(bool wrapGradient, params GradientStop[] gradientStops)
+            : base(wrapGradient, gradientStops)
+        {
+            Initialize();
+        }
+
+        #endregion
+
+        #region Methods
+
+        private void Initialize()
+        {
+            void OnGradientStopOnPropertyChanged(object? sender, PropertyChangedEventArgs args) => _isOrderedGradientListDirty = true;
+
+            foreach (GradientStop gradientStop in GradientStops)
+                gradientStop.PropertyChanged += OnGradientStopOnPropertyChanged;
+
+            GradientStops.CollectionChanged += (_, args) =>
+                                               {
+                                                   if (args.OldItems != null)
+                                                       foreach (GradientStop gradientStop in args.OldItems)
+                                                           gradientStop.PropertyChanged -= OnGradientStopOnPropertyChanged;
+
+                                                   if (args.NewItems != null)
+                                                       foreach (GradientStop gradientStop in args.NewItems)
+                                                           gradientStop.PropertyChanged += OnGradientStopOnPropertyChanged;
+                                               };
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Gets the linear interpolated <see cref="T:RGB.NET.Core.Color" /> at the given offset.
+        /// </summary>
+        /// <param name="offset">The percentage offset to take the color from.</param>
+        /// <returns>The <see cref="T:RGB.NET.Core.Color" /> at the specific offset.</returns>
+        public override Color GetColor(double offset)
+        {
+            if (GradientStops.Count == 0) return Color.Transparent;
+            if (GradientStops.Count == 1) return GradientStops[0].Color;
+
+            if (_isOrderedGradientListDirty)
+                _orderedGradientStops = new LinkedList<GradientStop>(GradientStops.OrderBy(x => x.Offset));
+
+            (GradientStop gsBefore, GradientStop gsAfter) = GetEnclosingGradientStops(offset, _orderedGradientStops, WrapGradient);
+
+            double blendFactor = 0;
+            if (!gsBefore.Offset.Equals(gsAfter.Offset))
+                blendFactor = ((offset - gsBefore.Offset) / (gsAfter.Offset - gsBefore.Offset));
+
+            double colA = ((gsAfter.Color.A - gsBefore.Color.A) * blendFactor) + gsBefore.Color.A;
+            double colR = ((gsAfter.Color.R - gsBefore.Color.R) * blendFactor) + gsBefore.Color.R;
+            double colG = ((gsAfter.Color.G - gsBefore.Color.G) * blendFactor) + gsBefore.Color.G;
+            double colB = ((gsAfter.Color.B - gsBefore.Color.B) * blendFactor) + gsBefore.Color.B;
+
+            return new Color(colA, colR, colG, colB);
+        }
+
+        /// <summary>
+        /// Get the two <see cref="GradientStop"/>s encapsulating the given offset.
+        /// </summary>
+        /// <param name="offset">The reference offset.</param>
+        /// <param name="orderedStops">The ordered list of <see cref="GradientStop"/> to choose from.</param>
+        /// <param name="wrap">Bool indicating if the gradient should be wrapped or not.</param>
+        /// <returns></returns>
+        protected virtual (GradientStop gsBefore, GradientStop gsAfter) GetEnclosingGradientStops(double offset, LinkedList<GradientStop> orderedStops, bool wrap)
+        {
+            LinkedList<GradientStop> gradientStops = new(orderedStops);
+
+            if (wrap)
+            {
+                GradientStop? gsBefore, gsAfter;
+
+                do
+                {
+                    gsBefore = gradientStops.LastOrDefault(n => n.Offset <= offset);
+                    if (gsBefore == null)
+                    {
+                        GradientStop lastStop = gradientStops.Last!.Value;
+                        gradientStops.AddFirst(new GradientStop(lastStop.Offset - 1, lastStop.Color));
+                        gradientStops.RemoveLast();
+                    }
+
+                    gsAfter = gradientStops.FirstOrDefault(n => n.Offset >= offset);
+                    if (gsAfter == null)
+                    {
+                        GradientStop firstStop = gradientStops.First!.Value;
+                        gradientStops.AddLast(new GradientStop(firstStop.Offset + 1, firstStop.Color));
+                        gradientStops.RemoveFirst();
+                    }
+
+                } while ((gsBefore == null) || (gsAfter == null));
+
+                return (gsBefore, gsAfter);
+            }
+
+            offset = ClipOffset(offset);
+            return (gradientStops.Last(n => n.Offset <= offset), gradientStops.First(n => n.Offset >= offset));
+        }
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/Gradients/RainbowGradient.cs

@@ -0,0 +1,109 @@
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+
+using System;
+using RGB.NET.Core;
+using RGB.NET.Presets.Decorators;
+
+namespace RGB.NET.Presets.Textures.Gradients
+{
+    /// <inheritdoc cref="AbstractDecoratable{T}" />
+    /// <inheritdoc cref="IGradient" />
+    /// <summary>
+    /// Represents a rainbow gradient which circles through all colors of the HUE-color-space.<br />
+    /// See <see href="http://upload.wikimedia.org/wikipedia/commons/a/ad/HueScale.svg" /> as reference.
+    /// </summary>
+    public class RainbowGradient : AbstractDecoratable<IGradientDecorator>, IGradient
+    {
+        #region Properties & Fields
+
+        private double _startHue;
+        /// <summary>
+        /// Gets or sets the hue (in degrees) to start from.
+        /// </summary>
+        public double StartHue
+        {
+            get => _startHue;
+            set => SetProperty(ref _startHue, value);
+        }
+
+        private double _endHue;
+        /// <summary>
+        /// Gets or sets the hue (in degrees) to end the with.
+        /// </summary>
+        public double EndHue
+        {
+            get => _endHue;
+            set => SetProperty(ref _endHue, value);
+        }
+
+        #endregion
+
+        #region Events
+
+        /// <inheritdoc />
+        public event EventHandler? GradientChanged;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RainbowGradient"/> class.
+        /// </summary>
+        /// <param name="startHue">The hue (in degrees) to start from (default: 0)</param>
+        /// <param name="endHue">The hue (in degrees) to end with (default: 360)</param>
+        public RainbowGradient(double startHue = 0, double endHue = 360)
+        {
+            this.StartHue = startHue;
+            this.EndHue = endHue;
+
+            PropertyChanged += (_, _) => OnGradientChanged();
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Gets the color on the rainbow at the given offset.
+        /// </summary>
+        /// <param name="offset">The percentage offset to take the color from.</param>
+        /// <returns>The color at the specific offset.</returns>
+        public Color GetColor(double offset)
+        {
+            double range = EndHue - StartHue;
+            double hue = StartHue + (range * offset);
+            return HSVColor.Create(hue, 1, 1);
+        }
+
+        /// <inheritdoc />
+        public void Move(double offset)
+        {
+            // RainbowGradient is calculated inverse
+            offset *= -1;
+
+            StartHue += offset;
+            EndHue += offset;
+
+            while ((StartHue > 360) && (EndHue > 360))
+            {
+                StartHue -= 360;
+                EndHue -= 360;
+            }
+            while ((StartHue < -360) && (EndHue < -360))
+            {
+                StartHue += 360;
+                EndHue += 360;
+            }
+        }
+
+        /// <summary>
+        /// Should be called to indicate that the gradient was changed.
+        /// </summary>
+        protected void OnGradientChanged() => GradientChanged?.Invoke(this, EventArgs.Empty);
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/LinearGradientTexture.cs

@@ -0,0 +1,79 @@
+// ReSharper disable CollectionNeverUpdated.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable ReturnTypeCanBeEnumerable.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable UnusedMember.Global
+
+using RGB.NET.Core;
+using RGB.NET.Presets.Helper;
+using RGB.NET.Presets.Textures.Gradients;
+
+namespace RGB.NET.Presets.Textures
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Represents a brush drawing a linear gradient.
+    /// </summary>
+    public sealed class LinearGradientTexture : AbstractGradientTexture
+    {
+        #region Properties & Fields
+
+        private Point _startPoint = new(0, 0.5);
+        /// <summary>
+        /// Gets or sets the start <see cref="Point"/> (as percentage in the range [0..1]) of the <see cref="IGradient"/> drawn by this <see cref="LinearGradientTexture"/>. (default: 0.0, 0.5)
+        /// </summary>
+        public Point StartPoint
+        {
+            get => _startPoint;
+            set => SetProperty(ref _startPoint, value);
+        }
+
+        private Point _endPoint = new(1, 0.5);
+        /// <summary>
+        /// Gets or sets the end <see cref="Point"/>  (as percentage in the range [0..1]) of the <see cref="IGradient"/> drawn by this <see cref="LinearGradientTexture"/>. (default: 1.0, 0.5)
+        /// </summary>
+        public Point EndPoint
+        {
+            get => _endPoint;
+            set => SetProperty(ref _endPoint, value);
+        }
+
+        #endregion
+
+        #region Constructor
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.LinearGradientTexture" /> class.
+        /// </summary>
+        /// <param name="gradient">The <see cref="T:RGB.NET.Presets.Gradients.IGradient" /> drawn by this <see cref="T:RGB.NET.Presets.Textures.LinearGradientTexture" />.</param>
+        public LinearGradientTexture(Size size, IGradient gradient)
+            : base(size, gradient)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.LinearGradientTexture" /> class.
+        /// </summary>
+        /// <param name="startPoint">The start <see cref="T:RGB.NET.Core.Point" /> (as percentage in the range [0..1]).</param>
+        /// <param name="endPoint">The end <see cref="T:RGB.NET.Core.Point" /> (as percentage in the range [0..1]).</param>
+        /// <param name="gradient">The <see cref="T:RGB.NET.Presets.Gradients.IGradient" /> drawn by this <see cref="T:RGB.NET.Presets.Textures.LinearGradientTexture" />.</param>
+        public LinearGradientTexture(Size size, IGradient gradient, Point startPoint, Point endPoint)
+            : base(size, gradient)
+        {
+            this.StartPoint = startPoint;
+            this.EndPoint = endPoint;
+        }
+
+        #endregion
+
+        #region Methods
+
+        protected override Color GetColor(in Point point)
+        {
+            double offset = GradientHelper.CalculateLinearGradientOffset(StartPoint, EndPoint, point);
+            return Gradient.GetColor(offset);
+        }
+
+        #endregion
+    }
+}

RGB.NET.Presets/Textures/RadialGradientTexture.cs

@@ -0,0 +1,78 @@
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable UnusedMember.Global
+
+using RGB.NET.Core;
+using RGB.NET.Presets.Helper;
+using RGB.NET.Presets.Textures.Gradients;
+
+namespace RGB.NET.Presets.Textures
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// Represents a brush drawing a radial gradient around a center point.
+    /// </summary>
+    public sealed class RadialGradientTexture : AbstractGradientTexture
+    {
+        #region Properties & Fields
+
+        private double _referenceDistance = GradientHelper.CalculateDistance(new Point(0.5, 0.5), new Point(0, 0));
+
+        private Point _center = new(0.5, 0.5);
+        /// <summary>
+        /// Gets or sets the center <see cref="Point"/> (as percentage in the range [0..1]) around which the <see cref="RadialGradientTexture"/> should be drawn. (default: 0.5, 0.5)
+        /// </summary>
+        public Point Center
+        {
+            get => _center;
+            set
+            {
+                if (SetProperty(ref _center, value))
+                    CalculateReferenceDistance();
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.RadialGradientTexture" /> class.
+        /// </summary>
+        /// <param name="gradient">The gradient drawn by the brush.</param>
+        public RadialGradientTexture(Size size, IGradient gradient)
+            : base(size, gradient)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:RGB.NET.Presets.Textures.RadialGradientTexture" /> class.
+        /// </summary>
+        /// <param name="center">The center point (as percentage in the range [0..1]).</param>
+        /// <param name="gradient">The gradient drawn by the brush.</param>
+        public RadialGradientTexture(Size size, IGradient gradient, Point center)
+            : base(size, gradient)
+        {
+            this.Center = center;
+        }
+
+        #endregion
+
+        #region Methods
+
+        private void CalculateReferenceDistance()
+        {
+            double referenceX = Center.X < 0.5 ? 1 : 0;
+            double referenceY = Center.Y < 0.5 ? 1 : 0;
+            _referenceDistance = GradientHelper.CalculateDistance(new Point(referenceX, referenceY), Center);
+        }
+
+        protected override Color GetColor(in Point point)
+        {
+            double distance = GradientHelper.CalculateDistance(point, Center);
+            double offset = distance / _referenceDistance;
+            return Gradient.GetColor(offset);
+        }
+
+        #endregion
+    }
+}