/// <summary>
/// Devuelve una versión del mismo tono de color sin ningún tipo de transparencia.
/// </summary>
public static Color Opaque(this Color color)
{
#if (UNITY_5 || UNITY_4)
return(new Color(color.r, color.g, color.b));
#else
return(Color.FromArgb(255, color));
#endif
}
/// <summary>
/// The display color
/// </summary>
/// <param name="blue">blue</param>
/// <param name="green">green</param>
/// <param name="red">red</param>
public DisplayColorAttribute(int blue, int green, int red)
{
#if UNITY_ANDROID || UNITY_IOS || UNITY_STANDALONE || UNITY_METRO || UNITY_EDITOR
_displayColor = new Color(red / 255.0f, green / 255.0f, blue / 255.0f, 1.0f);
#else
_displayColor = Color.FromArgb(red, green, blue);
#endif
}
/// <summary>
/// Devuelve una versión del mismo tono de color pero con el alfa especificado.
/// </summary>
public static Color WithAlpha(this Color color, float alpha)
{
#if (UNITY_5 || UNITY_4)
return(new Color(color.r, color.g, color.b, alpha));
#else
return(Color.FromArgb((int)(alpha * 255.0f), color));
#endif
}
public static Color Lerp(Color start, Color end, float parameter)
{
int a = (int)(((1.0f - parameter) * start.A) + (parameter * end.A));
int r = (int)(((1.0f - parameter) * start.R) + (parameter * end.R));
int g = (int)(((1.0f - parameter) * start.G) + (parameter * end.G));
int b = (int)(((1.0f - parameter) * start.B) + (parameter * end.B));
return(Color.FromArgb(a, r, g, b));
}
/// <summary>
/// Devuelve un color del mismo tono aplicando una reducción de brillo del 25%.
/// </summary>
public static Color Darker(this Color color)
{
#if (UNITY_5 || UNITY_4)
return(new Color(color.r * 0.75f, color.g * 0.75f, color.b * 0.75f, color.a));
#else
return(Color.FromArgb((int)color.A,
(((int)color.R) * 3) / 4,
(((int)color.G) * 3) / 4,
(((int)color.B) * 3) / 4));
#endif
}
/// <summary>
/// Devuelve un color del mismo tono aplicando una reducción de brillo con el factor especificado. Un factor
/// igual o menor que cero no alterará en absoluto el color, mientras que un factor igual o superior a uno lo
/// convertirá en negro puro. Los valores intermedios interpolan el efecto descrito.
/// </summary>
public static Color Darker(this Color color, float factor)
{
factor = factor < 0.0f ? 0.0f : (factor > 1.0f ? 1.0f : factor);
#if (UNITY_5 || UNITY_4)
return(new Color(color.r * factor, color.g * factor, color.b * factor, color.a));
#else
return(Color.FromArgb((int)color.A,
(int)(((float)color.R) * factor),
(int)(((float)color.G) * factor),
(int)(((float)color.B) * factor)));
#endif
}
/// <summary>
/// Convierte el objeto System.String actual en un objeto UnityEngine.Color, atendiendo a su representación en
/// hexadecimal. La respresentación hexadecimal deberá tener al menos una longitud de 6, en cuyo caso se
/// interpretarán los valores de los componentes R, G, y B del color. Si tiene dos caracteres más se intentará
/// además obtener el componente alfa del color. La cadena de texto podrá empezar opcionalmente por "0x" o por
/// "#" (estos prefijos serán simplemente ignorados). Si no se puede realizar la conversión, se devuelve el
/// color especificado como alternativa.
/// </summary>
public static Color ToColorFromHex(this string s, Color fallback)
{
// Eliminación de prefijos comunes de definición de colores en hexadecimal
s = s.Replace("0x", string.Empty);
s = s.Replace("#", string.Empty);
#if (UNITY_5 || UNITY_4)
// Convertir color de respaldo a bytes
global::UnityEngine.Color32 fallback32 = (global::UnityEngine.Color32)fallback;
// Intentar conversión
if (s.Length >= 6)
{
byte a = byte.MaxValue;
byte r = ColorExtensions.TryParseByte(s.Substring(0, 2), fallback32.r);
byte g = ColorExtensions.TryParseByte(s.Substring(2, 2), fallback32.g);
byte b = ColorExtensions.TryParseByte(s.Substring(4, 2), fallback32.b);
if (s.Length > 7)
{
a = ColorExtensions.TryParseByte(s.Substring(6, 2), byte.MaxValue);
}
return(new global::UnityEngine.Color32(r, g, b, a));
}
else
{
return(fallback);
}
#else
// Intentar conversión
if (s.Length >= 6)
{
byte a = byte.MaxValue;
byte r = ColorExtensions.TryParseByte(s.Substring(0, 2), fallback.R);
byte g = ColorExtensions.TryParseByte(s.Substring(2, 2), fallback.G);
byte b = ColorExtensions.TryParseByte(s.Substring(4, 2), fallback.B);
if (s.Length > 7)
{
a = ColorExtensions.TryParseByte(s.Substring(6, 2), byte.MaxValue);
}
return(Color.FromArgb(a, r, g, b));
}
else
{
return(fallback);
}
#endif
}
/// <summary>
/// Devuelve un color del mismo tono aplicando un incremento de brillo del 25%.
/// </summary>
public static Color Lighter(this Color color)
{
#if (UNITY_5 || UNITY_4)
return(new Color(color.r + (1.0f - color.r) * 0.25f,
color.g + (1.0f - color.g) * 0.25f,
color.b + (1.0f - color.b) * 0.25f,
color.a));
#else
return(Color.FromArgb((int)color.A,
(int)(color.R + (1.0f - color.R) * 0.25f),
(int)(color.G + (1.0f - color.G) * 0.25f),
(int)(color.B + (1.0f - color.B) * 0.25f)));
#endif
}
/// <summary>
/// Devuelve un color del mismo tono aplicando un incremento de brillo con el factor especificado. Un factor
/// igual o menor que cero no alterará en absoluto el color, mientras que un factor igual o superior a uno lo
/// convertirá en blanco puro. Los valores intermedios interpolan el efecto descrito.
/// </summary>
public static Color Lighter(this Color color, float factor)
{
factor = factor < 0.0f ? 0.0f : (factor > 1.0f ? 1.0f : factor);
#if (UNITY_5 || UNITY_4)
return(new Color(color.r + (1.0f - color.r) * factor,
color.g + (1.0f - color.g) * factor,
color.b + (1.0f - color.b) * factor,
color.a));
#else
return(Color.FromArgb((int)color.A,
(int)(color.R + (1.0f - color.R) * factor),
(int)(color.G + (1.0f - color.G) * factor),
(int)(color.B + (1.0f - color.B) * factor)));
#endif
}
