/// <summary>Creates the a texture with a rectangle with given color and border.</summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="color">The color.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>A color map with a rectangle image in the colorMap.</returns> public static ColorMap CreateRectangleColorMap(int width, int height, int borderWidth, GUIColor color, GUIColor borderColor) { var colorMap = new ColorMap(width, height); var left = borderWidth; var right = width - borderWidth; var top = borderWidth; var bottom = height - borderWidth; GUIColor colorToUse; for (var wY = 0; wY < height; wY++) { for (var wX = 0; wX < width; wX++) { colorToUse = color; if (wX < left || wX >= right) { colorToUse = borderColor; } if (wY < top || wY >= bottom) { colorToUse = borderColor; } colorMap.Set(wX, wY, colorToUse); } } return(colorMap); }
/// <summary> /// Modifies an existing brightness level. </summary> /// <remarks> /// To reduce brightness use a number smaller then 1. To increase brightness use a number larger then 1. </remarks> /// <param name="colorToModify">The original color.</param> /// <param name="brightness">The luminance delta.</param> /// <returns>An adjusted color.</returns> public static GUIColor ModifyBrightness(GUIColor colorToModify, double brightness) { var hsl = RGBToHSL(colorToModify); hsl.L *= brightness; return(HSLToRGB(hsl)); }
/// <summary>Converts RGB to CMYK.</summary> /// <param name="colorToConvert">A color to convert.</param> /// <returns>A CMYK object.</returns> public static CMYK RGBToCMYK(GUIColor colorToConvert) // ReSharper restore InconsistentNaming { var cmyk = new CMYK(); var low = 1.0; cmyk.Cyan = (double)(255 - colorToConvert.R) / 255; if (low > cmyk.Cyan) { low = cmyk.Cyan; } cmyk.Magenta = (double)(255 - colorToConvert.G) / 255; if (low > cmyk.Magenta) { low = cmyk.Magenta; } cmyk.Yellow = (double)(255 - colorToConvert.B) / 255; if (low > cmyk.Yellow) { low = cmyk.Yellow; } if (low > 0.0) { cmyk.KeyBlack = low; } return(cmyk); }
/// <summary> /// Sets the absolute Hue level. </summary> /// <remarks>Accepted values 0-1.</remarks> /// <param name="color">An original color.</param> /// <param name="hue">The Hue value to impose.</param> /// <returns>An adjusted color.</returns> public static GUIColor SetHue(GUIColor color, double hue) { var hsl = RGBToHSL(color); hsl.H = hue; return(HSLToRGB(hsl)); }
/// <summary> /// Sets the absolute saturation level. </summary> /// <remarks>Accepted values 0-1.</remarks> /// <param name="colorToChange">An original color.</param> /// <param name="saturation">The saturation value to impose.</param> /// <returns>An adjusted color.</returns> public static GUIColor SetSaturation(GUIColor colorToChange, double saturation) { var hsl = RGBToHSL(colorToChange); hsl.S = saturation; return(HSLToRGB(hsl)); }
/// <summary> /// Sets the absolute brightness of a color.</summary> /// <param name="colorToChange">Original color.</param> /// <param name="brightness">The luminance level to impose.</param> /// <returns>an adjusted color.</returns> public static GUIColor SetBrightness(GUIColor colorToChange, double brightness) { var hsl = RGBToHSL(colorToChange); hsl.L = brightness; return(HSLToRGB(hsl)); }
/// <summary> /// Modifies an existing Saturation level. </summary> /// <remarks> /// To reduce Saturation use a number smaller then 1. To increase Saturation use a number larger then 1. </remarks> /// <param name="colorToModify">The original color.</param> /// <param name="saturation">The saturation delta.</param> /// <returns>An adjusted color.</returns> public static GUIColor ModifySaturation(GUIColor colorToModify, double saturation) { var hsl = RGBToHSL(colorToModify); hsl.S *= saturation; return(HSLToRGB(hsl)); }
/// <summary> /// Initializes a new instance of the <see cref="ColorBoxGradient"/> class. /// </summary> /// <param name="name">The name.</param> public ColorBoxGradient(string name) : base(name) { this.hsl = new HSL { H = 0.3, S = 0.6, L = 0.8 }; this.rgba = AdobeColors.HSLToRGB(this.hsl); this.drawStyle = DrawStyle.Hue; Config.Width = Theme.ControlWidth; Config.Height = Theme.ControlWidth; this.redrawControlFlag = true; }
/// <summary>Creates the circle texture.</summary> /// <param name="radius">The radius.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="borderInnerTransitionWidth">Width of the border inner transition.</param> /// <param name="borderOuterTransitionWidth">Width of the border outer transition.</param> /// <param name="color">The color.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>A array with a representation of a circle inside.</returns> public static GUIColor[] CreateCircleTexture(int radius, int borderWidth, int borderInnerTransitionWidth, int borderOuterTransitionWidth, GUIColor color, GUIColor borderColor) { int x; var y = -1; var diameter = (radius + 2) * 2; // DVector2 center = new DVector2(0, 0); var center = new DVector2((diameter - 1) / 2f, (diameter - 1) / 2f); var colors = new GUIColor[diameter * diameter]; for (var i = 0; i < colors.Length; i++) { if (i % diameter == 0) { y += 1; } x = i % diameter; // var distance = new DVector2(Math.Abs(center.X - x), Math.Abs(center.Y - y)); var diff = new DVector2(x, y) - center; var length = diff.Length; // distance.Length(); if (length > radius) { colors[i] = GUIColor.Transparent(); } else if (length >= radius - borderOuterTransitionWidth) { var transitionAmount = (length - (radius - borderOuterTransitionWidth)) / borderOuterTransitionWidth; transitionAmount = 255 * (1 - transitionAmount); colors[i] = new GUIColor(borderColor.R, borderColor.G, borderColor.B, (byte)transitionAmount); } else if (length > radius - (borderWidth + borderOuterTransitionWidth)) { colors[i] = borderColor; } else if (length >= radius - (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth)) { var transitionAmount = (length - (radius - (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth))) / (borderInnerTransitionWidth + 1); colors[i] = new GUIColor( (byte)Lerp(color.R, borderColor.R, transitionAmount), (byte)Lerp(color.G, borderColor.G, transitionAmount), (byte)Lerp(color.B, borderColor.B, transitionAmount)); } else { colors[i] = color; } } return(colors); }
/// <summary>Creates the circle texture.</summary> /// <param name="radius">The radius.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="borderInnerTransitionWidth">Width of the border inner transition.</param> /// <param name="borderOuterTransitionWidth">Width of the border outer transition.</param> /// <param name="color">The color.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>A array with a representation of a circle inside.</returns> public static GUIColor[] CreateCircleTexture(int radius, int borderWidth, int borderInnerTransitionWidth, int borderOuterTransitionWidth, GUIColor color, GUIColor borderColor) { int x; var y = -1; var diameter = (radius + 2) * 2; // DVector2 center = new DVector2(0, 0); var center = new DVector2((diameter - 1) / 2f, (diameter - 1) / 2f); var colors = new GUIColor[diameter * diameter]; for (var i = 0; i < colors.Length; i++) { if (i % diameter == 0) { y += 1; } x = i % diameter; // var distance = new DVector2(Math.Abs(center.X - x), Math.Abs(center.Y - y)); var diff = new DVector2(x, y) - center; var length = diff.Length; // distance.Length(); if (length > radius) { colors[i] = GUIColor.Transparent(); } else if (length >= radius - borderOuterTransitionWidth) { var transitionAmount = (length - (radius - borderOuterTransitionWidth)) / borderOuterTransitionWidth; transitionAmount = 255 * (1 - transitionAmount); colors[i] = new GUIColor(borderColor.R, borderColor.G, borderColor.B, (byte)transitionAmount); } else if (length > radius - (borderWidth + borderOuterTransitionWidth)) { colors[i] = borderColor; } else if (length >= radius - (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth)) { var transitionAmount = (length - (radius - (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth))) / (borderInnerTransitionWidth + 1); colors[i] = new GUIColor( (byte)Lerp(color.R, borderColor.R, transitionAmount), (byte)Lerp(color.G, borderColor.G, transitionAmount), (byte)Lerp(color.B, borderColor.B, transitionAmount)); } else { colors[i] = color; } } return colors; }
/// <summary> /// Converts a color from HSL to RGB. </summary> /// <remarks>Adapted from the algorithm in Foley and Van-Dam.</remarks> /// <param name="colorToConvert">The HSL value.</param> /// <returns>A Color structure containing the equivalent RGB values.</returns> public static GUIColor HSLToRGB(HSL colorToConvert) { #if DEBUG if (colorToConvert == null) { throw new ArgumentNullException("colorToConvert"); } #endif // ReSharper disable JoinDeclarationAndInitializer int max, mid, min; double q; // ReSharper restore JoinDeclarationAndInitializer max = Round(colorToConvert.L * 255); min = Round((1.0 - colorToConvert.S) * (colorToConvert.L / 1.0) * 255); q = (double)(max - min) / 255; if (colorToConvert.H >= 0 && colorToConvert.H <= (double)1 / 6) { mid = Round((((colorToConvert.H - 0) * q) * 1530) + min); return(GUIColor.FromARGB(max, mid, min)); } if (colorToConvert.H <= (double)1 / 3) { mid = Round((-((colorToConvert.H - ((double)1 / 6)) * q) * 1530) + max); return(GUIColor.FromARGB(mid, max, min)); } if (colorToConvert.H <= 0.5) { mid = Round((((colorToConvert.H - ((double)1 / 3)) * q) * 1530) + min); return(GUIColor.FromARGB(min, max, mid)); } if (colorToConvert.H <= (double)2 / 3) { mid = Round((-((colorToConvert.H - 0.5) * q) * 1530) + max); return(GUIColor.FromARGB(min, mid, max)); } if (colorToConvert.H <= (double)5 / 6) { mid = Round((((colorToConvert.H - ((double)2 / 3)) * q) * 1530) + min); return(GUIColor.FromARGB(mid, min, max)); } if (colorToConvert.H <= 1.0) { mid = Round((-((colorToConvert.H - ((double)5 / 6)) * q) * 1530) + max); return(GUIColor.FromARGB(max, min, mid)); } return(GUIColor.FromARGB(0, 0, 0)); }
/// <summary>Tries to set the specified color at location x,y.</summary> /// <param name="locationX">The location x.</param> /// <param name="locationY">The location y.</param> /// <param name="color">The color.</param> /// <returns>true when there is success setting it.</returns> public bool TrySet(int locationX, int locationY, GUIColor color) { var pos = locationX + (locationY * this.width); if (pos > this.colors.Length) { return(false); } this.colors[pos] = color; return(true); }
/// <summary>Creates a line with given height and width.</summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="color">The color.</param> /// <returns>A color array containing a representation of a line.</returns> public static GUIColor[] CreateFlat(int width, int height, GUIColor color) { // Texture2D texture2D = new Texture2D(graphicsDevice, 2, lineWidth + 2); var count = width * height; var colorArray = new GUIColor[count]; for (var i = 0; i < count; i++) { colorArray[i] = color; } return(colorArray); }
/// <summary> /// Called when graphics resources need to be loaded. /// /// Use this for the usage of : /// - creation of the internal embedded controls. /// - setting of the variables and resources in this control /// - to load any game-specific graphics resources /// - take over the config width and height and use it into State /// - overriding how this item looks like , by settings its texture or theme /// /// Call base.LoadContent before you do your override code, this will cause : /// - State.SourceRectangle to be reset to the Config.Size /// </summary> public override void LoadContent() { base.LoadContent(); this.UpdateDrawPositionByConfigAndParent(); this.UpdateDrawSizeByConfig(); this.UpdateDrawSourceRectangleByConfig(); const int Width = 10; const int Height = 10; var color = new GUIColor(0, 0, 255); this.CurrentTextureName = this.Manager.ImageCompositor.CreateFlatTexture(this.Name + "-Background", Width, Height, color); }
/// <summary> /// Initializes a new instance of the <see cref="ColorSliderVertical"/> class. /// </summary> /// <param name="name">The name.</param> public ColorSliderVertical(string name) : base(name) { // Initialize Colors this.hsl = new HSL { H = 1.0, S = 1.0, L = 1.0 }; this.rgba = AdobeColors.HSLToRGB(this.hsl); // pick a format to show this.drawStyle = DrawStyle.Hue; this.Padding = 9; Config.Width = Theme.ControlHeight; Config.Height = Theme.ControlWidth; }
/// <summary> /// Sit in between the start and end color by specified percentage. /// </summary> /// <param name="startColor">The start color.</param> /// <param name="endColor">The end color.</param> /// <param name="percentage">The percentage.</param> /// <returns>The interpolated color.</returns> /// <exception cref="System.ArgumentException">value must be between 0 and 1.</exception> public static GUIColor Lerp(GUIColor startColor, GUIColor endColor, float percentage) { if (percentage < 0 || percentage > 1) { throw new ArgumentException("Value must be between 0 and 1"); } var r = (byte)(((endColor.R - startColor.R) * percentage) + startColor.R); var g = (byte)(((endColor.G - startColor.G) * percentage) + startColor.G); var b = (byte)(((endColor.B - startColor.B) * percentage) + startColor.B); var a = (byte)(((endColor.A - startColor.A) * percentage) + startColor.A); return(new GUIColor(r, g, b, a)); }
/// <summary> /// Reverses this color-array in this instance. /// </summary> /// <returns>A reversed color-map.</returns> public ColorMap Reverse() { var reverseData = new GUIColor[this.Width * this.Height]; var r = reverseData.Length - 1; foreach (var guiColor in this.colors) { reverseData[r] = guiColor; r--; } var map = new ColorMap(reverseData, this.width, this.height); return(map); }
/// <summary>Converts CMYK to RGB.</summary> /// <param name="colorToConvert">A color to convert.</param> /// <returns>A Color object.</returns> public static GUIColor CMYKToRGB(CMYK colorToConvert) { #if DEBUG if (colorToConvert == null) { throw new ArgumentNullException("colorToConvert"); } #endif int red, green, blue; red = Round(255 - (255 * colorToConvert.Cyan)); green = Round(255 - (255 * colorToConvert.Magenta)); blue = Round(255 - (255 * colorToConvert.Yellow)); return(GUIColor.FromARGB(red, green, blue)); }
private static void SetSelectionRectangle(Rectangle rectangle, TextBoxSelectionBox textBoxSelectionBox, GUIColor color) { if (rectangle.Width >= 1 && rectangle.Height >= 1) { textBoxSelectionBox.CurrentTextureName = textBoxSelectionBox.Manager.ImageCompositor.CreateRectangleTexture(textBoxSelectionBox.Name, (int)rectangle.Width, (int)rectangle.Height, 0, GUIColor.White(), GUIColor.White()); var size = textBoxSelectionBox.Manager.ImageCompositor.ReadSizeTexture(textBoxSelectionBox.CurrentTextureName); var count = (int)size.X * (int)size.Y; var colorArray = new GUIColor[count]; for (var i = 0; i < count; i++) { colorArray[i] = color; } var map = new ColorMap(colorArray, (int)size.X, (int)size.Y); textBoxSelectionBox.Manager.ImageCompositor.UpdateTexture(textBoxSelectionBox.CurrentTextureName, map); textBoxSelectionBox.ConfigActive = true; } }
/// <summary> /// Contrasts the color. /// </summary> /// <param name="color">The color.</param> /// <returns>The contrasted color.</returns> public static GUIColor ContrastColor(GUIColor color) { int d; // Counting the perceptive luminance - human eye favors green color... var ar = 0.299 * color.R; var ag = 0.587 * color.G; var ab = 0.114 * color.B; var a = 1 - ((ar + ag + ab) / 255); if (a < 0.5) { d = 0; // bright colors - black font } else { d = 255; // dark colors - white font } return(GUIColor.FromARGB(d, d, d)); }
/// <summary>Creates a rectangle texture.</summary> /// <param name="preferredName">The preferred name to use.</param> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="fillColor">Color of the fill.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>The URL to the created texture resource that looks like a rectangle.</returns> /// <exception cref="ArgumentException">Width can not be zero or less;width /// or /// height can not be zero or less;height /// or /// Control name can not be null;preferredName /// or /// Border width can not be smaller then zero;borderWidth.</exception> public override string CreateRectangleTexture(string preferredName, int width, int height, int borderWidth, GUIColor fillColor, GUIColor borderColor) { #if DEBUG if (width <= 0) { throw new ArgumentException("width can not be zero or less", "width"); } if (height <= 0) { throw new ArgumentException("height can not be zero or less", "height"); } if (string.IsNullOrEmpty(preferredName)) { throw new ArgumentException("Control name can not be null", "preferredName"); } if (borderWidth < 0) { throw new ArgumentException("Border width can not be smaller then zero", "borderWidth"); } #endif var textureName = this.resourcesTexture.Create(preferredName, width, height, fillColor); // var colordata = RectangleBrush.CreateRectangleColorMap(width, height,borderWidth,1,1, fillColor, borderColor); var colordata = ColorMapDrawer.CreateRectangleColorMap(width, height, borderWidth, fillColor, borderColor); // var colordata = ColorMapDrawer.CreateRoundedRectangleColorMap( // width, // height, // borderWidth, // 20, // fillColor, // borderColor); this.resourcesTexture.Update(textureName, colordata.ToArray()); return textureName; }
private static ColorMap CreateRoundedCornerColorMap(int innerRadius, int outerRadius, GUIColor innerColor, GUIColor outerColor) { int x; int y; int width = outerRadius; int height = outerRadius; var array = new ColorMap(width, height); for (x = 0; x < +width; x++) { for (y = 0; y < +height; y++) { // get the distance to x,y var r = Math.Sqrt((x * x) + (y * y)); if (r < innerRadius) { array.Set(x, y, innerColor); } else if (r >= innerRadius && r < outerRadius) { array.Set(x, y, outerColor); } } } return array; }
/// <summary>Sets the specified color at location x,y.</summary> /// <param name="locationX">The location x.</param> /// <param name="locationY">The location y.</param> /// <param name="color">The color.</param> public void Set(int locationX, int locationY, GUIColor color) { this.colors[locationX + (locationY * this.width)] = color; }
private static void CreateEmptyRectangleColorMap(ref ColorMap colorMap, int imageWidth, int imageHeight, GUIColor colorToUse) { for (var wY = 0; wY < imageHeight; wY++) { for (var wX = 0; wX < imageWidth; wX++) { colorMap.Set(wX, wY, colorToUse); } } }
private static void SetPixel(ref ColorMap colorMap, int imageWidth, int imageHeight, float x, float y, GUIColor colorToUse) { // all is centered , so shift it back t bitmap coordinates // shift x to bitmap location var tempX = (imageWidth / 2) + (int)x; if (tempX >= imageWidth) { return; } if (tempX <= 0) { return; } // shift y to bitmap location var tempY = (imageHeight / 2) + (int)y; if (tempY >= imageHeight) { return; } if (tempY <= 0) { return; } // get the location into my array colorMap.Set(tempX, tempY, colorToUse); }
/// <summary>Creates a high quality rounded corner color-map.</summary> /// <param name="innerRadius">The inner radius.</param> /// <param name="outerRadius">The outer radius.</param> /// <param name="innerColor">Color of the inner.</param> /// <param name="outerColor">Color of the outer.</param> /// <returns>A color-map with a high quality rounded corner inside.</returns> private static ColorMap CreateHighQualityRoundedCornerColorMap(int innerRadius, int outerRadius, GUIColor innerColor, GUIColor outerColor) { int x; int y; const int GrowFactor = 4; int width = outerRadius * GrowFactor; int height = outerRadius * GrowFactor; // create a grown round corner var array = new ColorMap(width, height); for (x = 0; x < +width; x++) { for (y = 0; y < +height; y++) { // get the distance to x,y var r = Math.Sqrt((x * x) + (y * y)); if (r < innerRadius * GrowFactor) { array.Set(x, y, innerColor); } else if (r >= innerRadius * GrowFactor && r < outerRadius * GrowFactor) { array.Set(x, y, outerColor); } } } // and shrink it array = ResizeImage(array, outerRadius, outerRadius); return(array); }
/// <summary> /// Draws a horizontal line on the given color-map. /// </summary> /// <param name="colorMap">The color map to draw into.</param> /// <param name="y">The y position to draw the line.</param> /// <param name="startX">The start x to draw the line.</param> /// <param name="endX">The end x to draw the line.</param> /// <param name="colorToUse">The color to use.</param> private static void DrawHorizontalLineOnColorMap(ref ColorMap colorMap, int y, int startX, int endX, GUIColor colorToUse) { for (var x = startX; x < endX; x++) { colorMap.Set(x, y, colorToUse); } }
/// <summary> /// Called when graphics resources need to be loaded. /// /// Use this for the usage of : /// - creation of the internal embedded controls. /// - setting of the variables and resources in this control /// - to load any game-specific graphics resources /// - take over the config width and height and use it into State /// - overriding how this item looks like , by settings its texture or theme /// /// Call base.LoadContent before you do your override code, this will cause : /// - State.SourceRectangle to be reset to the Config.Size /// </summary> public override void LoadContent() { if (this.hsl == null) { this.hsl = new HSL { H = 1.0, S = 1.0, L = 1.0 }; this.rgba = AdobeColors.HSLToRGB(this.hsl); } Config.Width = Theme.ControlHeight; Config.Height = Theme.ControlWidth; // create left indicator this.IndicatorLeft = new ColorSliderVerticalIndicator(Name + "-indicatorLeft") { Side = Side.Left, Manager = Manager }; this.AddControl(this.IndicatorLeft); // create right indicator this.IndicatorRight = new ColorSliderVerticalIndicator(Name + "-indicatorRight") { Side = Side.Right, Manager = Manager }; this.AddControl(this.IndicatorRight); this.SetIndicatorPosition(0); this.RedrawControl(); // do the basic stuff base.LoadContent(); this.UpdateDrawPositionByConfigAndParent(); this.UpdateDrawSizeByConfig(); }
/// <summary> /// Draws a color filled rectangle on given color-map. /// </summary> /// <param name="colorMap">The color map.</param> /// <param name="startX">The start x.</param> /// <param name="startY">The start y.</param> /// <param name="endX">The end x.</param> /// <param name="endY">The end y.</param> /// <param name="colorToUse">The color to use.</param> private static void DrawRectangleOnColorMap(ref ColorMap colorMap, int startX, int startY, int endX, int endY, GUIColor colorToUse) { for (var x = startX; x < endX; x++) { for (var y = startY; y < endY; y++) { colorMap.Set(x, y, colorToUse); } } }
/// <summary>Creates a rectangle texture. </summary> /// <param name="preferredName">The preferred name to use.</param> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="fillColor">Color of the fill.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>The URL to the created texture resource that looks like a rectangle.</returns> public abstract string CreateRectangleTexture(string preferredName, int width, int height, int borderWidth, GUIColor fillColor, GUIColor borderColor);
/// <summary>Draws the string using specified location font and color.</summary> /// <param name="fontName">Name of the font.</param> /// <param name="text">The text to draw.</param> /// <param name="position">The position of the text.</param> /// <param name="fontColor">Color of the font.</param> public abstract void DrawString(string fontName, string text, DVector2 position, GUIColor fontColor);
/// <summary> /// Draws the vertical line on the given color-map. /// </summary> /// <param name="colorMap">The color map to draw into.</param> /// <param name="x">The x position to draw the line.</param> /// <param name="startY">The start y to draw the line.</param> /// <param name="endY">The end y to draw the line.</param> /// <param name="colorToUse">The color to use.</param> private static void DrawVerticalLineOnColorMap(ref ColorMap colorMap, int x, int startY, int endY, GUIColor colorToUse) { for (int y = startY; y < endY; y++) { colorMap.Set(x, y, colorToUse); } }
/// <summary>Creates a high quality rounded corner color-map.</summary> /// <param name="innerRadius">The inner radius.</param> /// <param name="outerRadius">The outer radius.</param> /// <param name="innerColor">Color of the inner.</param> /// <param name="outerColor">Color of the outer.</param> /// <returns>A color-map with a high quality rounded corner inside.</returns> private static ColorMap CreateHighQualityRoundedCornerColorMap(int innerRadius, int outerRadius, GUIColor innerColor, GUIColor outerColor) { int x; int y; const int GrowFactor = 4; int width = outerRadius * GrowFactor; int height = outerRadius * GrowFactor; // create a grown round corner var array = new ColorMap(width, height); for (x = 0; x < +width; x++) { for (y = 0; y < +height; y++) { // get the distance to x,y var r = Math.Sqrt((x * x) + (y * y)); if (r < innerRadius * GrowFactor) { array.Set(x, y, innerColor); } else if (r >= innerRadius * GrowFactor && r < outerRadius * GrowFactor) { array.Set(x, y, outerColor); } } } // and shrink it array = ResizeImage(array, outerRadius, outerRadius); return array; }
/// <summary> /// Modifies an existing Saturation level. </summary> /// <remarks> /// To reduce Saturation use a number smaller then 1. To increase Saturation use a number larger then 1. </remarks> /// <param name="colorToModify">The original color.</param> /// <param name="saturation">The saturation delta.</param> /// <returns>An adjusted color.</returns> public static GUIColor ModifySaturation(GUIColor colorToModify, double saturation) { var hsl = RGBToHSL(colorToModify); hsl.S *= saturation; return HSLToRGB(hsl); }
/// <summary> /// Sets the absolute Hue level. </summary> /// <remarks>Accepted values 0-1.</remarks> /// <param name="color">An original color.</param> /// <param name="hue">The Hue value to impose.</param> /// <returns>An adjusted color.</returns> public static GUIColor SetHue(GUIColor color, double hue) { var hsl = RGBToHSL(color); hsl.H = hue; return HSLToRGB(hsl); }
/// <summary>Converts RGB to HSL.</summary> /// <remarks>Takes advantage of what is already built in to .NET by using the Color.GetHue, Color.GetSaturation and Color.GetBrightness methods.</remarks> /// <param name="colorToConvert">A Color to convert.</param> /// <returns>An HSL value.</returns> public static HSL RGBToHSL(GUIColor colorToConvert) { var hsl = new HSL(); // ReSharper disable JoinDeclarationAndInitializer int max, min, diff; // ReSharper restore JoinDeclarationAndInitializer // Of our RGB values, assign the highest value to Max, and the Smallest to Min if (colorToConvert.R > colorToConvert.G) { max = colorToConvert.R; min = colorToConvert.G; } else { max = colorToConvert.G; min = colorToConvert.R; } if (colorToConvert.B > max) { max = colorToConvert.B; } else if (colorToConvert.B < min) { min = colorToConvert.B; } diff = max - min; // Luminance - a.k.a. Brightness - Adobe photoshop uses the logic that the // site VBspeed regards (regarded) as too primitive = superior decides the // level of brightness. hsl.L = (double)max / 255; // Saturation if (max == 0) { hsl.S = 0; // Protecting from the impossible operation of division by zero. } else { hsl.S = (double)diff / max; // The logic of Adobe Photoshops is this simple. } // Hue R is situated at the angel of 360 degrees; // G 120 degrees // B 240 degrees double q; if (diff == 0) { q = 0; // Protecting from the impossible operation of division by zero. } else { q = (double)60 / diff; } if (max == colorToConvert.R) { if (colorToConvert.G < colorToConvert.B) { hsl.H = (360 + (q * (colorToConvert.G - colorToConvert.B))) / 360; } else { hsl.H = q * (colorToConvert.G - colorToConvert.B) / 360; } } else if (max == colorToConvert.G) { hsl.H = (120 + (q * (colorToConvert.B - colorToConvert.R))) / 360; } else if (max == colorToConvert.B) { hsl.H = (240 + (q * (colorToConvert.R - colorToConvert.G))) / 360; } else { hsl.H = 0.0; } return hsl; }
/// <summary>Converts RGB to CMYK.</summary> /// <param name="colorToConvert">A color to convert.</param> /// <returns>A CMYK object.</returns> public static CMYK RGBToCMYK(GUIColor colorToConvert) // ReSharper restore InconsistentNaming { var cmyk = new CMYK(); var low = 1.0; cmyk.Cyan = (double)(255 - colorToConvert.R) / 255; if (low > cmyk.Cyan) { low = cmyk.Cyan; } cmyk.Magenta = (double)(255 - colorToConvert.G) / 255; if (low > cmyk.Magenta) { low = cmyk.Magenta; } cmyk.Yellow = (double)(255 - colorToConvert.B) / 255; if (low > cmyk.Yellow) { low = cmyk.Yellow; } if (low > 0.0) { cmyk.KeyBlack = low; } return cmyk; }
/// <summary>Converts RGB to HSL.</summary> /// <remarks>Takes advantage of what is already built in to .NET by using the Color.GetHue, Color.GetSaturation and Color.GetBrightness methods.</remarks> /// <param name="colorToConvert">A Color to convert.</param> /// <returns>An HSL value.</returns> public static HSL RGBToHSL(GUIColor colorToConvert) { var hsl = new HSL(); // ReSharper disable JoinDeclarationAndInitializer int max, min, diff; // ReSharper restore JoinDeclarationAndInitializer // Of our RGB values, assign the highest value to Max, and the Smallest to Min if (colorToConvert.R > colorToConvert.G) { max = colorToConvert.R; min = colorToConvert.G; } else { max = colorToConvert.G; min = colorToConvert.R; } if (colorToConvert.B > max) { max = colorToConvert.B; } else if (colorToConvert.B < min) { min = colorToConvert.B; } diff = max - min; // Luminance - a.k.a. Brightness - Adobe photoshop uses the logic that the // site VBspeed regards (regarded) as too primitive = superior decides the // level of brightness. hsl.L = (double)max / 255; // Saturation if (max == 0) { hsl.S = 0; // Protecting from the impossible operation of division by zero. } else { hsl.S = (double)diff / max; // The logic of Adobe Photoshops is this simple. } // Hue R is situated at the angel of 360 degrees; // G 120 degrees // B 240 degrees double q; if (diff == 0) { q = 0; // Protecting from the impossible operation of division by zero. } else { q = (double)60 / diff; } if (max == colorToConvert.R) { if (colorToConvert.G < colorToConvert.B) { hsl.H = (360 + (q * (colorToConvert.G - colorToConvert.B))) / 360; } else { hsl.H = q * (colorToConvert.G - colorToConvert.B) / 360; } } else if (max == colorToConvert.G) { hsl.H = (120 + (q * (colorToConvert.B - colorToConvert.R))) / 360; } else if (max == colorToConvert.B) { hsl.H = (240 + (q * (colorToConvert.R - colorToConvert.G))) / 360; } else { hsl.H = 0.0; } return(hsl); }
/// <summary> /// Contrasts the color. /// </summary> /// <param name="color">The color.</param> /// <returns>The contrasted color.</returns> public static GUIColor ContrastColor(GUIColor color) { int d; // Counting the perceptive luminance - human eye favors green color... var ar = 0.299 * color.R; var ag = 0.587 * color.G; var ab = 0.114 * color.B; var a = 1 - ((ar + ag + ab) / 255); if (a < 0.5) { d = 0; // bright colors - black font } else { d = 255; // dark colors - white font } return GUIColor.FromARGB(d, d, d); }
private static ColorMap CreateRoundedCornerColorMap(int innerRadius, int outerRadius, GUIColor innerColor, GUIColor outerColor) { int x; int y; int width = outerRadius; int height = outerRadius; var array = new ColorMap(width, height); for (x = 0; x < +width; x++) { for (y = 0; y < +height; y++) { // get the distance to x,y var r = Math.Sqrt((x * x) + (y * y)); if (r < innerRadius) { array.Set(x, y, innerColor); } else if (r >= innerRadius && r < outerRadius) { array.Set(x, y, outerColor); } } } return(array); }
/// <summary> /// Sets the absolute brightness of a color.</summary> /// <param name="colorToChange">Original color.</param> /// <param name="brightness">The luminance level to impose.</param> /// <returns>an adjusted color.</returns> public static GUIColor SetBrightness(GUIColor colorToChange, double brightness) { var hsl = RGBToHSL(colorToChange); hsl.L = brightness; return HSLToRGB(hsl); }
/// <summary> /// Sit in between the start and end color by specified percentage. /// </summary> /// <param name="startColor">The start color.</param> /// <param name="endColor">The end color.</param> /// <param name="percentage">The percentage.</param> /// <returns>The interpolated color.</returns> /// <exception cref="System.ArgumentException">value must be between 0 and 1.</exception> public static GUIColor Lerp(GUIColor startColor, GUIColor endColor, float percentage) { if (percentage < 0 || percentage > 1) { throw new ArgumentException("Value must be between 0 and 1"); } var r = (byte)(((endColor.R - startColor.R) * percentage) + startColor.R); var g = (byte)(((endColor.G - startColor.G) * percentage) + startColor.G); var b = (byte)(((endColor.B - startColor.B) * percentage) + startColor.B); var a = (byte)(((endColor.A - startColor.A) * percentage) + startColor.A); return new GUIColor(r, g, b, a); }
/// <summary> /// Modifies an existing brightness level. </summary> /// <remarks> /// To reduce brightness use a number smaller then 1. To increase brightness use a number larger then 1. </remarks> /// <param name="colorToModify">The original color.</param> /// <param name="brightness">The luminance delta.</param> /// <returns>An adjusted color.</returns> public static GUIColor ModifyBrightness(GUIColor colorToModify, double brightness) { var hsl = RGBToHSL(colorToModify); hsl.L *= brightness; return HSLToRGB(hsl); }
/// <summary>Creates a rounded rectangle texture with given color and border.</summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="borderWidth">Width of the border.</param> /// <param name="cornerSize">Size of the corner.</param> /// <param name="fillColor">Color of the fill.</param> /// <param name="borderColor">Color of the border.</param> /// <returns>A color-map with a rounded rectangle inside.</returns> public static ColorMap CreateRoundedRectangleColorMap(int width, int height, int borderWidth, int cornerSize, GUIColor fillColor, GUIColor borderColor) { var colorMap = new ColorMap(width, height); if (cornerSize > width / 2) { cornerSize = width / 2; } if (cornerSize > height / 2) { cornerSize = height / 2; } // draw top horizontal lines for (var y = 0; y < cornerSize; y++) { if (y < borderWidth) { DrawHorizontalLineOnColorMap(ref colorMap, y, cornerSize, width - cornerSize, borderColor); } else { DrawHorizontalLineOnColorMap(ref colorMap, y, cornerSize, width - cornerSize, fillColor); } } // draw bottom horizontal lines for (var y = height - cornerSize; y < height; y++) { if (y < height - borderWidth) { DrawHorizontalLineOnColorMap(ref colorMap, y, cornerSize, width - cornerSize, fillColor); } else { DrawHorizontalLineOnColorMap(ref colorMap, y, cornerSize, width - cornerSize, borderColor); } } // draw left vertical lines for (var x = 0; x < cornerSize; x++) { if (x < borderWidth) { DrawVerticalLineOnColorMap(ref colorMap, x, cornerSize, height - cornerSize, borderColor); } else { DrawVerticalLineOnColorMap(ref colorMap, x, cornerSize, height - cornerSize, fillColor); } } // draw right vertical lines for (var x = width - cornerSize; x < width; x++) { if (x < width - borderWidth) { DrawVerticalLineOnColorMap(ref colorMap, x, cornerSize, height - cornerSize, fillColor); } else { DrawVerticalLineOnColorMap(ref colorMap, x, cornerSize, height - cornerSize, borderColor); } } // draw internal rectangle DrawRectangleOnColorMap(ref colorMap, cornerSize, cornerSize, width - cornerSize, height - cornerSize, fillColor); // create the bottom right corner var bottomRightCorner = CreateHighQualityRoundedCornerColorMap(cornerSize - borderWidth, cornerSize, fillColor, borderColor); PlaceSourceColorMapIntoTargetColorMap(bottomRightCorner, ref colorMap, width - cornerSize, height - cornerSize); // create the bottom left corner var bottomLeftCorner = FlipColorMapHorizontal(bottomRightCorner); PlaceSourceColorMapIntoTargetColorMap(bottomLeftCorner, ref colorMap, 0, height - cornerSize); // create the top right corner var topRightCorner = FlipColorMapHVertical(bottomRightCorner); PlaceSourceColorMapIntoTargetColorMap(topRightCorner, ref colorMap, width - cornerSize, 0); // create the bottom left corner var topLeftCorner = FlipColorMapHorizontal(topRightCorner); PlaceSourceColorMapIntoTargetColorMap(topLeftCorner, ref colorMap, 0, 0); return(colorMap); }
/// <summary> /// Sets the absolute saturation level. </summary> /// <remarks>Accepted values 0-1.</remarks> /// <param name="colorToChange">An original color.</param> /// <param name="saturation">The saturation value to impose.</param> /// <returns>An adjusted color.</returns> public static GUIColor SetSaturation(GUIColor colorToChange, double saturation) { var hsl = RGBToHSL(colorToChange); hsl.S = saturation; return HSLToRGB(hsl); }
/// <summary> /// Draws the specified texture using specified draw-state , with a tint color. /// </summary> /// <param name="name">The name of the item to draw.</param> /// <param name="drawState">The state that contains all the info to draw the item.</param> /// <param name="tintColor">The color to use to tint the shown item.</param> public abstract void Draw(string name, DrawState drawState, GUIColor tintColor);
/// <summary>Creates a line with given height and width.</summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="color">The color.</param> /// <returns>A color array containing a representation of a line.</returns> public static GUIColor[] CreateFlat(int width, int height, GUIColor color) { // Texture2D texture2D = new Texture2D(graphicsDevice, 2, lineWidth + 2); var count = width * height; var colorArray = new GUIColor[count]; for (var i = 0; i < count; i++) { colorArray[i] = color; } return colorArray; }
/// <summary> /// Clears the current render target with given color. /// </summary> /// <param name="clearColor">Color of the clear.</param> public abstract void Clear(GUIColor clearColor);
/// <summary> /// Redraws the box. /// </summary> private void RedrawBox() { // when there are no changes , do nothing if (this.currentrgba.Equals(this.rgba)) { return; } // we have a new color , destroy the old , plant the new if (Manager.ImageCompositor.Contains(this.CurrentTextureName)) { // destroy the old ! Manager.ImageCompositor.Delete(this.CurrentTextureName); } // create the new this.CurrentTextureName = Manager.ImageCompositor.CreateRectangleTexture(this.Name + "-FillColor", (int)Config.Width, (int)Config.Height, 1, this.rgba, Theme.BorderColor); this.currentrgba = this.rgba; }
/// <summary> /// Creates a flat texture with one color. /// </summary> /// <param name="preferredName">The preferred name to use.</param> /// <param name="width">The width of the line texture.</param> /// <param name="height">The height of the line texture.</param> /// <param name="color">The fill color of the line texture.</param> /// <returns>the name to use to find the texture back.</returns> public abstract string CreateFlatTexture(string preferredName, int width, int height, GUIColor color);
/// <summary> /// Initializes a new instance of the <see cref="Grid"/> class. /// </summary> /// <param name="name">The name.</param> public Grid(string name) : base(name) { this.cellHeight = Theme.ControlHeight; this.cellWidth = Theme.ControlWidth; this.configLineWidth = DefaultGridLineWidth; this.configColumnCount = 4; this.configRowCount = 4; Config.Width = this.cellWidth * this.ConfigRowCount; Config.Height = this.cellHeight * this.ConfigColumnCount; this.gridColor = Theme.FillColor; this.mustredraw = true; }