Added some basic brushes

RGB.NET.Brushes/Gradients/AbstractGradient.cs

@@ -0,0 +1,87 @@
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+
+using System.Collections.Generic;
+using System.Linq;
+using RGB.NET.Core;
+
+namespace RGB.NET.Brushes.Gradients
+{
+    /// <summary>
+    /// Represents a basic gradient.
+    /// </summary>
+    public abstract class AbstractGradient : IGradient
+    {
+        #region Properties & Fields
+
+        /// <summary>
+        /// Gets a list of the stops used by this <see cref="AbstractGradient"/>.
+        /// </summary>
+        public IList<GradientStop> GradientStops { get; } = new List<GradientStop>();
+
+        /// <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; set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AbstractGradient"/> class.
+        /// </summary>
+        protected AbstractGradient()
+        { }
+
+        /// <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)
+        {
+            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;
+
+            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(n => n.Offset);
+            if (offset > max)
+                return max;
+
+            double min = GradientStops.Min(n => n.Offset);
+            return offset < min ? min : offset;
+        }
+
+        /// <inheritdoc />
+        public abstract Color GetColor(double offset);
+
+        #endregion
+    }
+}

RGB.NET.Brushes/Gradients/GradientStop.cs

@@ -0,0 +1,42 @@
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable MemberCanBePrivate.Global
+
+using RGB.NET.Core;
+
+namespace RGB.NET.Brushes.Gradients
+{
+    /// <summary>
+    /// Represents a stop on a gradient.
+    /// </summary>
+    public class GradientStop
+    {
+        #region Properties & Fields
+
+        /// <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; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Color"/> of this <see cref="GradientStop"/>.
+        /// </summary>
+        public Color Color { get; set; }
+
+        #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.Brushes/Gradients/IGradient.cs

@@ -0,0 +1,17 @@
+using RGB.NET.Core;
+
+namespace RGB.NET.Brushes.Gradients
+{
+    /// <summary>
+    /// Represents a basic gradient.
+    /// </summary>
+    public interface IGradient
+    {
+        /// <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);
+    }
+}

RGB.NET.Brushes/Gradients/LinearGradient.cs

@@ -0,0 +1,95 @@
+// ReSharper disable UnusedMember.Global
+
+using System.Collections.Generic;
+using System.Linq;
+using RGB.NET.Core;
+
+namespace RGB.NET.Brushes.Gradients
+{
+    /// <summary>
+    /// Represents a linear interpolated gradient with n stops.
+    /// </summary>
+    public class LinearGradient : AbstractGradient
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinearGradient"/> class.
+        /// </summary>
+        public LinearGradient()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinearGradient"/> class.
+        /// </summary>
+        /// <param name="gradientStops">The stops with which the gradient should be initialized.</param>
+        public LinearGradient(params GradientStop[] gradientStops)
+            : base(gradientStops)
+        { }
+
+        /// <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="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)
+        { }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Gets the linear interpolated <see cref="Color"/> at the given offset.
+        /// </summary>
+        /// <param name="offset">The percentage offset to take the color from.</param>
+        /// <returns>The <see cref="Color"/> at the specific offset.</returns>
+        public override Color GetColor(double offset)
+        {
+            if (GradientStops.Count == 0) return Color.Transparent;
+            if (GradientStops.Count == 1) return new Color(GradientStops.First().Color);
+
+            GradientStop gsBefore;
+            GradientStop gsAfter;
+
+            IList<GradientStop> orderedStops = GradientStops.OrderBy(x => x.Offset).ToList();
+            if (WrapGradient)
+            {
+                gsBefore = orderedStops.LastOrDefault(n => n.Offset <= offset);
+                if (gsBefore == null)
+                {
+                    GradientStop lastStop = orderedStops[orderedStops.Count - 1];
+                    gsBefore = new GradientStop(lastStop.Offset - 1, lastStop.Color);
+                }
+
+                gsAfter = orderedStops.FirstOrDefault(n => n.Offset >= offset);
+                if (gsAfter == null)
+                {
+                    GradientStop firstStop = orderedStops[0];
+                    gsAfter = new GradientStop(firstStop.Offset + 1, firstStop.Color);
+                }
+            }
+            else
+            {
+                offset = ClipOffset(offset);
+
+                gsBefore = orderedStops.Last(n => n.Offset <= offset);
+                gsAfter = orderedStops.First(n => n.Offset >= offset);
+            }
+
+            double blendFactor = 0;
+            if (!gsBefore.Offset.Equals(gsAfter.Offset))
+                blendFactor = ((offset - gsBefore.Offset) / (gsAfter.Offset - gsBefore.Offset));
+
+            byte colA = (byte)(((gsAfter.Color.A - gsBefore.Color.A) * blendFactor) + gsBefore.Color.A);
+            byte colR = (byte)(((gsAfter.Color.R - gsBefore.Color.R) * blendFactor) + gsBefore.Color.R);
+            byte colG = (byte)(((gsAfter.Color.G - gsBefore.Color.G) * blendFactor) + gsBefore.Color.G);
+            byte colB = (byte)(((gsAfter.Color.B - gsBefore.Color.B) * blendFactor) + gsBefore.Color.B);
+
+            return new Color(colA, colR, colG, colB);
+        }
+
+        #endregion
+    }
+}

RGB.NET.Brushes/Gradients/RainbowGradient.cs

@@ -0,0 +1,61 @@
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+
+using RGB.NET.Core;
+
+namespace RGB.NET.Brushes.Gradients
+{
+    /// <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 : IGradient
+    {
+        #region Properties & Fields
+
+        /// <summary>
+        /// Gets or sets the hue (in degrees) to start from.
+        /// </summary>
+        public double StartHue { get; set; }
+
+        /// <summary>
+        /// Gets or sets the hue (in degrees) to end the with.
+        /// </summary>
+        public double EndHue { get; set; }
+
+        #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;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <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)) % 360f;
+            if (hue < 0)
+                hue += 360;
+            return new Color(hue, 1f, 1f);
+        }
+
+        #endregion
+    }
+}