using System;
using System.Collections.Generic;
using System.Linq;

namespace Chernobyl.Graphics
{
    /// <summary>
    /// Represents a color with red, green, blue, and alpha components or channels.
    /// </summary>
    [Serializable]
    public struct ColorRgba : IEquatable<ColorRgba>, IComparable<ColorRgba>
    {
        /// <param name="red">A value between 0 and 255 representing the red component of the color.</param>
        /// <param name="green">A value between 0 and 255 representing the green component of the color.</param>
        /// <param name="blue">A value between 0 and 255 representing the green component of the color.</param>
        public ColorRgba(byte red, byte green, byte blue) : this(red, green, blue, (byte)MaxChannelByteValue)
        {}

        /// <param name="red">A value between 0.0 and 1.0 representing the red component of the color.</param>
        /// <param name="green">A value between 0.0 and 1.0 representing the green component of the color.</param>
        /// <param name="blue">A value between 0.0 and 1.0 representing the green component of the color.</param>
        /// <param name="alpha">A value between 0.0 and 1.0 representing the alpha component of the color.</param>
        public ColorRgba(float red, float green, float blue, float alpha)
            : this(ColorFloatToByte(red), ColorFloatToByte(green), ColorFloatToByte(blue), ColorFloatToByte(alpha))
        {}

        /// <param name="red">A value between 0.0 and 1.0 representing the red component of the color.</param>
        /// <param name="green">A value between 0.0 and 1.0 representing the green component of the color.</param>
        /// <param name="blue">A value between 0.0 and 1.0 representing the green component of the color.</param>
        public ColorRgba(float red, float green, float blue) : this(red, green, blue, 1.0f)
        {}

        /// <param name="red">A value between 0 and 255 representing the red component of the color.</param>
        /// <param name="green">A value between 0 and 255 representing the green component of the color.</param>
        /// <param name="blue">A value between 0 and 255 representing the green component of the color.</param>
        /// <param name="alpha">A value between 0 and 255 representing the alpha component of the color.</param>
        public ColorRgba(byte red, byte green, byte blue, byte alpha)
            : this()
        {
            Rgba = new[] { red, green, blue, alpha };
        }

        /// <param name="rgba">The 0.0 to 1.0 values of each of the channels where rgba[0]
        /// is red, rgba[1] is green, rgba[2] is blue, and rgba[3] is alpha.</param>
        /// <exception cref="ArgumentException">Thrown if the length of rgba is not 4.</exception>
        public ColorRgba(IEnumerable<float> rgba) : this(rgba.Select(ColorFloatToByte).ToArray())
        {}

        /// <param name="rgba">The 0 to 255 values of each of the channels where rgba[0]
        /// is red, rgba[1] is green, rgba[2] is blue, and rgba[3] is alpha.</param>
        /// <exception cref="ArgumentException">Thrown if the length of rgba is not 4.</exception>
        public ColorRgba(byte[] rgba): this()
        {
            if (rgba.Length != 4)
                throw new ArgumentException("There must be at least four components (channels) in the passed in array", nameof(rgba));

            Rgba = rgba;
        }

        /// <summary>
        /// Gets or sets a value between 0.0 and 255 representing the blue component or channel of
        /// this color.
        /// </summary>
        public byte B => Rgba[2];

        /// <summary>
        /// Gets or sets a value between 0.0 and 255 representing the green component or channel of
        /// this color.
        /// </summary>
        public byte G => Rgba[1];

        /// <summary>
        /// Gets or sets a value between 0 and 255 representing the red component or channel of
        /// this color.
        /// </summary>
        public byte R => Rgba[0];

        /// <summary>
        /// Gets or sets a value between 0.0 and 255 representing the alpha component or channel of
        /// this color.
        /// </summary>
        public byte A => Rgba[3];

        /// <summary>
        /// Gets color in red, green, blue, and alpha order.
        /// </summary>
        public byte[] Rgba { get; }

        /// <summary>
        /// Retrieves the color in the blue, green, red, alpha order.
        /// </summary>
        public byte[] Bgra => new[] {B, G, R, A};

        /// <summary>
        /// Compares the values of one color to another.
        /// </summary>
        /// <param name="leftSide">The color from the left side of the equality operation.</param>
        /// <param name="rightSide">The color from the right side of the equality operation.</param>
        /// <returns>True if the values of the colors are the same, false if otherwise.</returns>
        public static bool operator ==(ColorRgba leftSide, ColorRgba rightSide)
        {
            return (leftSide.R == rightSide.R &&
                    leftSide.G == rightSide.G &&
                    leftSide.B == rightSide.B &&
                    leftSide.A == rightSide.A);
        }

        /// <summary>
        /// Compares the values of one color to another.
        /// </summary>
        /// <param name="leftSide">The color from the left side of the equality operation.</param>
        /// <param name="rightSide">The color from the right side of the equality operation.</param>
        /// <returns>True if the values of the colors are the different, false if otherwise.</returns>
        public static bool operator !=(ColorRgba leftSide, ColorRgba rightSide)
        {
            return !(leftSide == rightSide);
        }

        /// <inheritdoc />
        public bool Equals(ColorRgba other)
        {
            return (this == other);
        }

        /// <inheritdoc />
        public override bool Equals(object obj)
        {
            return (obj is ColorRgba color && this == color);
        }

        /// <inheritdoc />
        public override int GetHashCode()
        {
            return (A.GetHashCode() ^ A.GetHashCode() +
                    R.GetHashCode() ^ R.GetHashCode() +
                    G.GetHashCode() ^ G.GetHashCode() +
                    B.GetHashCode() ^ B.GetHashCode());
        }

        /// <summary>
        /// Converts this color into a string of this format: "{R:000 G:000 B:000 A:000}" where
        /// '000' is a number between 0 and 255.
        /// </summary>
        public override string ToString()
        {
            return "{R:" + R + " G:" + G + " B:" + B + " A:" + A + "}";
        }

        /// <summary>
        /// Compares this color to another color and returns a signed integer
        /// that indicates the relative order of the two colors being compared.
        /// </summary>
        /// <param name="other">The color to compare to this color.</param>
        /// <returns>Less than zero if this color is less than the
        /// <paramref name="other"/> color, 0 if they are equal, and greater
        /// than zero if the <paramref name="other"/> color is greater than this
        /// color.</returns>
        public int CompareTo(ColorRgba other)
        {
            var thisBytes = Rgba;
            var otherBytes = other.Rgba;

            // If the system architecture is little-endian (that is, little end first),
            // reverse the byte array so that the result is the same as if we were
            // comparing on a little endian machine.
            if (BitConverter.IsLittleEndian == false)
            {
                Array.Reverse(thisBytes);
                Array.Reverse(otherBytes);
            }

            var thisValue = BitConverter.ToInt32(thisBytes, 0);
            var otherValue = BitConverter.ToInt32(otherBytes, 0);

            return thisValue.CompareTo(otherValue);
        }

        /// <summary>
        /// Linear interpolates between two colors.
        /// </summary>
        /// <param name="color1">The color to interpolate from or the source color.</param>
        /// <param name="color2">The color to interpolate to or the destination color.</param>
        /// <param name="amount">A value from 0.0 to 1.0 specifying how much weight to apply
        /// to the interpolation. A value closer to 0.0 will look more like <paramref name="color1"/>
        /// while a color closer to 1.0 will look more like <paramref name="color2"/>.</param>
        /// <returns>The interpolated color.</returns>
        public static ColorRgba Lerp(ColorRgba color1, ColorRgba color2, float amount)
        {
            Lerp(out var result, color1, color2, amount);
            return result;
        }

        /// <summary>
        /// Linear interpolates between two colors. This is the exactly the same as the other
        /// Lerp method in this class except it takes in an out parameter for the result. Use
        /// this method instead of the other method if speed is a concern.
        /// </summary>
        /// <param name="result">The interpolated color.</param>
        /// <param name="color1">The color to interpolate from or the source color.</param>
        /// <param name="color2">The color to interpolate to or the destination color.</param>
        /// <param name="amount">A value from 0.0 to 1.0 specifying how much weight to apply
        /// to the interpolation. A value closer to 0.0 will look more like <paramref name="color1"/>
        /// while a color closer to 1.0 will look more like <paramref name="color2"/>.</param>
        public static void Lerp(out ColorRgba result, ColorRgba color1, ColorRgba color2, float amount)
        {
            // TODO: put the lerp equation into a math library and then use that math library method here.
            result = new ColorRgba(color1.R + (color2.R - color1.R) * amount,
                               color1.G + (color2.G - color1.G) * amount,
                               color1.B + (color2.B - color1.B) * amount,
                               color1.A + (color2.A - color1.A) * amount);
        }

        /// <summary>
        /// Generates a set of random colors and puts them in the
        /// passed in colors array.
        /// </summary>
        /// <param name="colors">The array of colors to fill with the random
        /// colors</param>
        /// <param name="count">The number of colors needed.</param>
        public static void Random(out ColorRgba[] colors, uint count)
        {
            colors = new ColorRgba[count];
            Random(ref colors);
        }

        /// <summary>
        /// Generates a set of random colors and puts them in the
        /// passed in colors array.
        /// </summary>
        /// <param name="colors">The array of colors to fill with the random colors</param>
        /// <exception cref="ArgumentException">Thrown if <paramref name="colors"/> does not
        /// have at least one color.</exception>
        public static void Random(ref ColorRgba[] colors)
        {
            if (colors.Length == 0)
                throw new ArgumentException("The passed in array of colors must have at least one color.", nameof(colors));

            var numColors = (uint)colors.Length;
            var rand = new Random();

            var numBytes = numColors * 4;
            var buffer = new byte[numBytes];
            rand.NextBytes(buffer);

            uint byteCounter = 0;
            for (var i = 0; i < numColors; ++i)
                colors[i] = new ColorRgba(buffer[byteCounter++], buffer[byteCounter++], buffer[byteCounter++], buffer[byteCounter++]);
        }

        /// <summary>
        /// The size of the entire color structure in bytes.
        /// </summary>
        [NonSerialized]
        public const short ByteSize = 4;

        /// <summary>
        /// Represents the largest channel byte value there is.
        /// </summary>
        [NonSerialized]
        public const double MaxChannelByteValue = 255.0;

        /// <summary>
        /// Converts a floating point color component to a byte.
        /// </summary>
        public static byte ColorDoubleToByte(double value) => (byte) (value * MaxChannelByteValue);

        /// <summary>
        /// Converts a floating point color component to a byte.
        /// </summary>
        public static byte ColorFloatToByte(float value) => ColorDoubleToByte(value);

        /// <summary>
        /// Converts a byte color component to a double.
        /// </summary>
        public static double ColorByteToDouble(byte value) => value / MaxChannelByteValue;

        /// <summary>
        /// Converts a byte color component to a float.
        /// </summary>
        public static float ColorByteToFloat(byte value) => Convert.ToSingle(ColorByteToDouble(value));

        #region Predefined Colors

        /// <summary>
        /// The color (205, 92, 92) in RGB.
        /// </summary>
        public static ColorRgba IndianRed => new ColorRgba(205, 92, 92);

        /// <summary>
        /// The color (240, 128, 128) in RGB.
        /// </summary>
        public static ColorRgba LightCoral => new ColorRgba(240, 128, 128);

        /// <summary>
        /// The color (250, 128, 114) in RGB.
        /// </summary>
        public static ColorRgba Salmon => new ColorRgba(250, 128, 114);

        /// <summary>
        /// The color (233, 150, 122) in RGB.
        /// </summary>
        public static ColorRgba DarkSalmon => new ColorRgba(233, 150, 122);

        /// <summary>
        /// The color (255, 160, 122) in RGB.
        /// </summary>
        public static ColorRgba LightSalmon => new ColorRgba(255, 160, 122);

        /// <summary>
        /// The color (220, 20, 60) in RGB.
        /// </summary>
        public static ColorRgba Crimson => new ColorRgba(220, 20, 60);

        /// <summary>
        /// The color (255, 0, 0) in RGB.
        /// </summary>
        public static ColorRgba Red => new ColorRgba(255, 0, 0);

        /// <summary>
        /// The color (178, 34, 34) in RGB.
        /// </summary>
        public static ColorRgba FireBrick => new ColorRgba(178, 34, 34);

        /// <summary>
        /// The color (139, 0, 0) in RGB.
        /// </summary>
        public static ColorRgba DarkRed => new ColorRgba(139, 0, 0);

        /// <summary>
        /// The color (255, 192, 203) in RGB.
        /// </summary>
        public static ColorRgba Pink => new ColorRgba(255, 192, 203);

        /// <summary>
        /// The color (255, 182, 193) in RGB.
        /// </summary>
        public static ColorRgba LightPink => new ColorRgba(255, 182, 193);

        /// <summary>
        /// The color (255, 105, 180) in RGB.
        /// </summary>
        public static ColorRgba HotPink => new ColorRgba(255, 105, 180);

        /// <summary>
        /// The color (255, 20, 147) in RGB.
        /// </summary>
        public static ColorRgba DeepPink => new ColorRgba(255, 20, 147);

        /// <summary>
        /// The color (199, 21, 133) in RGB.
        /// </summary>
        public static ColorRgba MediumVioletRed => new ColorRgba(199, 21, 133);

        /// <summary>
        /// The color (219, 112, 147) in RGB.
        /// </summary>
        public static ColorRgba PaleVioletRed => new ColorRgba(219, 112, 147);

        /// <summary>
        /// The color (255, 127, 80) in RGB.
        /// </summary>
        public static ColorRgba Coral => new ColorRgba(255, 127, 80);

        /// <summary>
        /// The color (255, 99, 71) in RGB.
        /// </summary>
        public static ColorRgba Tomato => new ColorRgba(255, 99, 71);

        /// <summary>
        /// The color (255, 69, 0) in RGB.
        /// </summary>
        public static ColorRgba OrangeRed => new ColorRgba(255, 69, 0);

        /// <summary>
        /// The color (255, 140, 0) in RGB.
        /// </summary>
        public static ColorRgba DarkOrange => new ColorRgba(255, 140, 0);

        /// <summary>
        /// The color (255, 165, 0) in RGB.
        /// </summary>
        public static ColorRgba Orange => new ColorRgba(255, 165, 0);

        /// <summary>
        /// The color (255, 215, 0) in RGB.
        /// </summary>
        public static ColorRgba Gold => new ColorRgba(255, 215, 0);

        /// <summary>
        /// The color (255, 255, 0) in RGB.
        /// </summary>
        public static ColorRgba Yellow => new ColorRgba(255, 255, 0);

        /// <summary>
        /// The color (255, 255, 224) in RGB.
        /// </summary>
        public static ColorRgba LightYellow => new ColorRgba(255, 255, 224);

        /// <summary>
        /// The color (255, 250, 205) in RGB.
        /// </summary>
        public static ColorRgba LemonChiffon => new ColorRgba(255, 250, 205);

        /// <summary>
        /// The color (250, 250, 210) in RGB.
        /// </summary>
        public static ColorRgba LightGoldenrodYellow => new ColorRgba(250, 250, 210);

        /// <summary>
        /// The color (255, 239, 213) in RGB.
        /// </summary>
        public static ColorRgba PapayaWhip => new ColorRgba(255, 239, 213);

        /// <summary>
        /// The color (255, 228, 181) in RGB.
        /// </summary>
        public static ColorRgba Moccasin => new ColorRgba(255, 228, 181);

        /// <summary>
        /// The color (255, 218, 185) in RGB.
        /// </summary>
        public static ColorRgba PeachPuff => new ColorRgba(255, 218, 185);

        /// <summary>
        /// The color (238, 232, 170) in RGB.
        /// </summary>
        public static ColorRgba PaleGoldenrod => new ColorRgba(238, 232, 170);

        /// <summary>
        /// The color (240, 230, 140) in RGB.
        /// </summary>
        public static ColorRgba Khaki => new ColorRgba(240, 230, 140);

        /// <summary>
        /// The color (189, 183, 107) in RGB.
        /// </summary>
        public static ColorRgba DarkKhaki => new ColorRgba(189, 183, 107);

        /// <summary>
        /// The color (230, 230, 250) in RGB.
        /// </summary>
        public static ColorRgba Lavender => new ColorRgba(230, 230, 250);

        /// <summary>
        /// The color (216, 191, 216) in RGB.
        /// </summary>
        public static ColorRgba Thistle => new ColorRgba(216, 191, 216);

        /// <summary>
        /// The color (221, 160, 221) in RGB.
        /// </summary>
        public static ColorRgba Plum => new ColorRgba(221, 160, 221);

        /// <summary>
        /// The color (238, 130, 238) in RGB.
        /// </summary>
        public static ColorRgba Violet => new ColorRgba(238, 130, 238);

        /// <summary>
        /// The color (218, 112, 214) in RGB.
        /// </summary>
        public static ColorRgba Orchid => new ColorRgba(218, 112, 214);

        /// <summary>
        /// The color (255, 0, 255) in RGB.
        /// </summary>
        public static ColorRgba Fuchsia => new ColorRgba(255, 0, 255);

        /// <summary>
        /// The color (255, 0, 255) in RGB.
        /// </summary>
        public static ColorRgba Magenta => new ColorRgba(255, 0, 255);

        /// <summary>
        /// The color (186, 85, 211) in RGB.
        /// </summary>
        public static ColorRgba MediumOrchid => new ColorRgba(186, 85, 211);

        /// <summary>
        /// The color (147, 112, 219) in RGB.
        /// </summary>
        public static ColorRgba MediumPurple => new ColorRgba(147, 112, 219);

        /// <summary>
        /// The color (153, 102, 204) in RGB.
        /// </summary>
        public static ColorRgba Amethyst => new ColorRgba(153, 102, 204);

        /// <summary>
        /// The color (138, 43, 226) in RGB.
        /// </summary>
        public static ColorRgba BlueViolet => new ColorRgba(138, 43, 226);

        /// <summary>
        /// The color (148, 0, 211) in RGB.
        /// </summary>
        public static ColorRgba DarkViolet => new ColorRgba(148, 0, 211);

        /// <summary>
        /// The color (153, 50, 204) in RGB.
        /// </summary>
        public static ColorRgba DarkOrchid => new ColorRgba(153, 50, 204);

        /// <summary>
        /// The color (139, 0, 139) in RGB.
        /// </summary>
        public static ColorRgba DarkMagenta => new ColorRgba(139, 0, 139);

        /// <summary>
        /// The color (128, 0, 128) in RGB.
        /// </summary>
        public static ColorRgba Purple => new ColorRgba(128, 0, 128);

        /// <summary>
        /// The color (75, 0, 130) in RGB.
        /// </summary>
        public static ColorRgba Indigo => new ColorRgba(75, 0, 130);

        /// <summary>
        /// The color (106, 90, 205) in RGB.
        /// </summary>
        public static ColorRgba SlateBlue => new ColorRgba(106, 90, 205);

        /// <summary>
        /// The color (72, 61, 139) in RGB.
        /// </summary>
        public static ColorRgba DarkSlateBlue => new ColorRgba(72, 61, 139);

        /// <summary>
        /// The color (173, 255, 47) in RGB.
        /// </summary>
        public static ColorRgba GreenYellow => new ColorRgba(173, 255, 47);

        /// <summary>
        /// The color (127, 255, 0) in RGB.
        /// </summary>
        public static ColorRgba Chartreuse => new ColorRgba(127, 255, 0);

        /// <summary>
        /// The color (124, 252, 0) in RGB.
        /// </summary>
        public static ColorRgba LawnGreen => new ColorRgba(124, 252, 0);

        /// <summary>
        /// The color (0, 255, 0) in RGB.
        /// </summary>
        public static ColorRgba Lime => new ColorRgba(0, 255, 0);

        /// <summary>
        /// The color (50, 205, 50) in RGB.
        /// </summary>
        public static ColorRgba LimeGreen => new ColorRgba(50, 205, 50);

        /// <summary>
        /// The color (152, 251, 152) in RGB.
        /// </summary>
        public static ColorRgba PaleGreen => new ColorRgba(152, 251, 152);

        /// <summary>
        /// The color (144, 238, 144) in RGB.
        /// </summary>
        public static ColorRgba LightGreen => new ColorRgba(144, 238, 144);

        /// <summary>
        /// The color (0, 250, 154) in RGB.
        /// </summary>
        public static ColorRgba MediumSpringGreen => new ColorRgba(0, 250, 154);

        /// <summary>
        /// The color (0, 255, 127) in RGB.
        /// </summary>
        public static ColorRgba SpringGreen => new ColorRgba(0, 255, 127);

        /// <summary>
        /// The color (60, 179, 113) in RGB.
        /// </summary>
        public static ColorRgba MediumSeaGreen => new ColorRgba(60, 179, 113);

        /// <summary>
        /// The color (46, 139, 87) in RGB.
        /// </summary>
        public static ColorRgba SeaGreen => new ColorRgba(46, 139, 87);

        /// <summary>
        /// The color (34, 139, 34) in RGB.
        /// </summary>
        public static ColorRgba ForestGreen => new ColorRgba(34, 139, 34);

        /// <summary>
        /// The color (0, 128, 0) in RGB.
        /// </summary>
        public static ColorRgba Green => new ColorRgba(0, 128, 0);

        /// <summary>
        /// The color (0, 100, 0) in RGB.
        /// </summary>
        public static ColorRgba DarkGreen => new ColorRgba(0, 100, 0);

        /// <summary>
        /// The color (154, 205, 50) in RGB.
        /// </summary>
        public static ColorRgba YellowGreen => new ColorRgba(154, 205, 50);

        /// <summary>
        /// The color (107, 142, 35) in RGB.
        /// </summary>
        public static ColorRgba OliveDrab => new ColorRgba(107, 142, 35);

        /// <summary>
        /// The color (128, 128, 0) in RGB.
        /// </summary>
        public static ColorRgba Olive => new ColorRgba(128, 128, 0);

        /// <summary>
        /// The color (85, 107, 47) in RGB.
        /// </summary>
        public static ColorRgba DarkOliveGreen => new ColorRgba(85, 107, 47);

        /// <summary>
        /// The color (102, 205, 170) in RGB.
        /// </summary>
        public static ColorRgba MediumAquamarine => new ColorRgba(102, 205, 170);

        /// <summary>
        /// The color (143, 188, 143) in RGB.
        /// </summary>
        public static ColorRgba DarkSeaGreen => new ColorRgba(143, 188, 143);

        /// <summary>
        /// The color (32, 178, 170) in RGB.
        /// </summary>
        public static ColorRgba LightSeaGreen => new ColorRgba(32, 178, 170);

        /// <summary>
        /// The color (0, 139, 139) in RGB.
        /// </summary>
        public static ColorRgba DarkCyan => new ColorRgba(0, 139, 139);

        /// <summary>
        /// The color (0, 128, 128) in RGB.
        /// </summary>
        public static ColorRgba Teal => new ColorRgba(0, 128, 128);

        /// <summary>
        /// The color (0, 255, 255) in RGB.
        /// </summary>
        public static ColorRgba Aqua => new ColorRgba(0, 255, 255);

        /// <summary>
        /// The color (0, 255, 255) in RGB.
        /// </summary>
        public static ColorRgba Cyan => new ColorRgba(0, 255, 255);

        /// <summary>
        /// The color (224, 255, 255) in RGB.
        /// </summary>
        public static ColorRgba LightCyan => new ColorRgba(224, 255, 255);

        /// <summary>
        /// The color (175, 238, 238) in RGB.
        /// </summary>
        public static ColorRgba PaleTurquoise => new ColorRgba(175, 238, 238);

        /// <summary>
        /// The color (127, 255, 212) in RGB.
        /// </summary>
        public static ColorRgba Aquamarine => new ColorRgba(127, 255, 212);

        /// <summary>
        /// The color (64, 224, 208) in RGB.
        /// </summary>
        public static ColorRgba Turquoise => new ColorRgba(64, 224, 208);

        /// <summary>
        /// The color (72, 209, 204) in RGB.
        /// </summary>
        public static ColorRgba MediumTurquoise => new ColorRgba(72, 209, 204);

        /// <summary>
        /// The color (0, 206, 209) in RGB.
        /// </summary>
        public static ColorRgba DarkTurquoise => new ColorRgba(0, 206, 209);

        /// <summary>
        /// The color (95, 158, 160) in RGB.
        /// </summary>
        public static ColorRgba CadetBlue => new ColorRgba(95, 158, 160);

        /// <summary>
        /// The color (70, 130, 180) in RGB.
        /// </summary>
        public static ColorRgba SteelBlue => new ColorRgba(70, 130, 180);

        /// <summary>
        /// The color (176, 196, 222) in RGB.
        /// </summary>
        public static ColorRgba LightSteelBlue => new ColorRgba(176, 196, 222);

        /// <summary>
        /// The color (176, 224, 230) in RGB.
        /// </summary>
        public static ColorRgba PowderBlue => new ColorRgba(176, 224, 230);

        /// <summary>
        /// The color (173, 216, 230) in RGB.
        /// </summary>
        public static ColorRgba LightBlue => new ColorRgba(173, 216, 230);

        /// <summary>
        /// The color (135, 206, 235) in RGB.
        /// </summary>
        public static ColorRgba SkyBlue => new ColorRgba(135, 206, 235);

        /// <summary>
        /// The color (135, 206, 250) in RGB.
        /// </summary>
        public static ColorRgba LightSkyBlue => new ColorRgba(135, 206, 250);

        /// <summary>
        /// The color (0, 191, 255) in RGB.
        /// </summary>
        public static ColorRgba DeepSkyBlue => new ColorRgba(0, 191, 255);

        /// <summary>
        /// The color (30, 144, 255) in RGB.
        /// </summary>
        public static ColorRgba DodgerBlue => new ColorRgba(30, 144, 255);

        /// <summary>
        /// The color (100, 149, 237) in RGB.
        /// </summary>
        public static ColorRgba CornflowerBlue => new ColorRgba(100, 149, 237);

        /// <summary>
        /// The color (123, 104, 238) in RGB.
        /// </summary>
        public static ColorRgba MediumSlateBlue => new ColorRgba(123, 104, 238);

        /// <summary>
        /// The color (65, 105, 225) in RGB.
        /// </summary>
        public static ColorRgba RoyalBlue => new ColorRgba(65, 105, 225);

        /// <summary>
        /// The color (0, 0, 255) in RGB.
        /// </summary>
        public static ColorRgba Blue => new ColorRgba(0, 0, 255);

        /// <summary>
        /// The color (0, 0, 205) in RGB.
        /// </summary>
        public static ColorRgba MediumBlue => new ColorRgba(0, 0, 205);

        /// <summary>
        /// The color (0, 0, 139) in RGB.
        /// </summary>
        public static ColorRgba DarkBlue => new ColorRgba(0, 0, 139);

        /// <summary>
        /// The color (0, 0, 128) in RGB.
        /// </summary>
        public static ColorRgba Navy => new ColorRgba(0, 0, 128);

        /// <summary>
        /// The color (25, 25, 112) in RGB.
        /// </summary>
        public static ColorRgba MidnightBlue => new ColorRgba(25, 25, 112);

        /// <summary>
        /// The color (255, 248, 220) in RGB.
        /// </summary>
        public static ColorRgba Cornsilk => new ColorRgba(255, 248, 220);

        /// <summary>
        /// The color (255, 235, 205) in RGB.
        /// </summary>
        public static ColorRgba BlanchedAlmond => new ColorRgba(255, 235, 205);

        /// <summary>
        /// The color (255, 228, 196) in RGB.
        /// </summary>
        public static ColorRgba Bisque => new ColorRgba(255, 228, 196);

        /// <summary>
        /// The color (255, 222, 173) in RGB.
        /// </summary>
        public static ColorRgba NavajoWhite => new ColorRgba(255, 222, 173);

        /// <summary>
        /// The color (245, 222, 179) in RGB.
        /// </summary>
        public static ColorRgba Wheat => new ColorRgba(245, 222, 179);

        /// <summary>
        /// The color (222, 184, 135) in RGB.
        /// </summary>
        public static ColorRgba BurlyWood => new ColorRgba(222, 184, 135);

        /// <summary>
        /// The color (210, 180, 140) in RGB.
        /// </summary>
        public static ColorRgba Tan => new ColorRgba(210, 180, 140);

        /// <summary>
        /// The color (188, 143, 143) in RGB.
        /// </summary>
        public static ColorRgba RosyBrown => new ColorRgba(188, 143, 143);

        /// <summary>
        /// The color (244, 164, 96) in RGB.
        /// </summary>
        public static ColorRgba SandyBrown => new ColorRgba(244, 164, 96);

        /// <summary>
        /// The color (218, 165, 32) in RGB.
        /// </summary>
        public static ColorRgba Goldenrod => new ColorRgba(218, 165, 32);

        /// <summary>
        /// The color (184, 134, 11) in RGB.
        /// </summary>
        public static ColorRgba DarkGoldenrod => new ColorRgba(184, 134, 11);

        /// <summary>
        /// The color (205, 133, 63) in RGB.
        /// </summary>
        public static ColorRgba Peru => new ColorRgba(205, 133, 63);

        /// <summary>
        /// The color (210, 105, 30) in RGB.
        /// </summary>
        public static ColorRgba Chocolate => new ColorRgba(210, 105, 30);

        /// <summary>
        /// The color (139, 69, 19) in RGB.
        /// </summary>
        public static ColorRgba SaddleBrown => new ColorRgba(139, 69, 19);

        /// <summary>
        /// The color (160, 82, 45) in RGB.
        /// </summary>
        public static ColorRgba Sienna => new ColorRgba(160, 82, 45);

        /// <summary>
        /// The color (165, 42, 42) in RGB.
        /// </summary>
        public static ColorRgba Brown => new ColorRgba(165, 42, 42);

        /// <summary>
        /// The color (128, 0, 0) in RGB.
        /// </summary>
        public static ColorRgba Maroon => new ColorRgba(128, 0, 0);

        /// <summary>
        /// The color (255, 255, 255) in RGB.
        /// </summary>
        public static ColorRgba White => new ColorRgba(255, 255, 255);

        /// <summary>
        /// The color (255, 250, 250) in RGB.
        /// </summary>
        public static ColorRgba Snow => new ColorRgba(255, 250, 250);

        /// <summary>
        /// The color (240, 255, 240) in RGB.
        /// </summary>
        public static ColorRgba Honeydew => new ColorRgba(240, 255, 240);

        /// <summary>
        /// The color (245, 255, 250) in RGB.
        /// </summary>
        public static ColorRgba MintCream => new ColorRgba(245, 255, 250);

        /// <summary>
        /// The color (240, 255, 255) in RGB.
        /// </summary>
        public static ColorRgba Azure => new ColorRgba(240, 255, 255);

        /// <summary>
        /// The color (240, 248, 255) in RGB.
        /// </summary>
        public static ColorRgba AliceBlue => new ColorRgba(240, 248, 255);

        /// <summary>
        /// The color (248, 248, 255) in RGB.
        /// </summary>
        public static ColorRgba GhostWhite => new ColorRgba(248, 248, 255);

        /// <summary>
        /// The color (245, 245, 245) in RGB.
        /// </summary>
        public static ColorRgba WhiteSmoke => new ColorRgba(245, 245, 245);

        /// <summary>
        /// The color (255, 245, 238) in RGB.
        /// </summary>
        public static ColorRgba Seashell => new ColorRgba(255, 245, 238);

        /// <summary>
        /// The color (245, 245, 220) in RGB.
        /// </summary>
        public static ColorRgba Beige => new ColorRgba(245, 245, 220);

        /// <summary>
        /// The color (253, 245, 230) in RGB.
        /// </summary>
        public static ColorRgba OldLace => new ColorRgba(253, 245, 230);

        /// <summary>
        /// The color (255, 250, 240) in RGB.
        /// </summary>
        public static ColorRgba FloralWhite => new ColorRgba(255, 250, 240);

        /// <summary>
        /// The color (255, 255, 240) in RGB.
        /// </summary>
        public static ColorRgba Ivory => new ColorRgba(255, 255, 240);

        /// <summary>
        /// The color (250, 235, 215) in RGB.
        /// </summary>
        public static ColorRgba AntiqueWhite => new ColorRgba(250, 235, 215);

        /// <summary>
        /// The color (250, 240, 230) in RGB.
        /// </summary>
        public static ColorRgba Linen => new ColorRgba(250, 240, 230);

        /// <summary>
        /// The color (255, 240, 245) in RGB.
        /// </summary>
        public static ColorRgba LavenderBlush => new ColorRgba(255, 240, 245);

        /// <summary>
        /// The color (255, 228, 225) in RGB.
        /// </summary>
        public static ColorRgba MistyRose => new ColorRgba(255, 228, 225);

        /// <summary>
        /// The color (220, 220, 220) in RGB.
        /// </summary>
        public static ColorRgba Gainsboro => new ColorRgba(220, 220, 220);

        /// <summary>
        /// The color (211, 211, 211) in RGB.
        /// </summary>
        public static ColorRgba LightGrey => new ColorRgba(211, 211, 211);

        /// <summary>
        /// The color (192, 192, 192) in RGB.
        /// </summary>
        public static ColorRgba Silver => new ColorRgba(192, 192, 192);

        /// <summary>
        /// The color (169, 169, 169) in RGB.
        /// </summary>
        public static ColorRgba DarkGray => new ColorRgba(169, 169, 169);

        /// <summary>
        /// The color (128, 128, 128) in RGB.
        /// </summary>
        public static ColorRgba Gray => new ColorRgba(128, 128, 128);

        /// <summary>
        /// The color (105, 105, 105) in RGB.
        /// </summary>
        public static ColorRgba DimGray => new ColorRgba(105, 105, 105);

        /// <summary>
        /// The color (119, 136, 153) in RGB.
        /// </summary>
        public static ColorRgba LightSlateGray => new ColorRgba(119, 136, 153);

        /// <summary>
        /// The color (112, 128, 144) in RGB.
        /// </summary>
        public static ColorRgba SlateGray => new ColorRgba(112, 128, 144);

        /// <summary>
        /// The color (47, 79, 79) in RGB.
        /// </summary>
        public static ColorRgba DarkSlateGray => new ColorRgba(47, 79, 79);

        /// <summary>
        /// The color (0, 0, 0) in RGB.
        /// </summary>
        public static ColorRgba Black => new ColorRgba(0, 0, 0);

        #endregion // Predefined Colors
    }
}