Color (commons-core 1.9.2 API)

java.lang.Object
- net.lenni0451.commons.color.Color

public class Color
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`static Color`	`BLACK`
`static Color`	`BLUE`
`static Color`	`CYAN`
`static Color`	`DARK_GRAY`
`static Color`	`GRAY`
`static Color`	`GREEN`
`static Color`	`LIGHT_GRAY`
`static Color`	`MAGENTA`
`static Color`	`ORANGE`
`static Color`	`PINK`
`static Color`	`RED`
`static Color`	`TRANSPARENT`
`static Color`	`WHITE`
`static Color`	`YELLOW`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Color`	`brighter()`
`Color`	`brighter(float factor)` Brighten this color by the given factor.
`Color`	`darker()`
`Color`	`darker(float factor)` Darken this color by the given factor.
`static Color`	`directABGR(int a, int b, int g, int r)` Directly create a color from alpha, blue, green and red values. This method does not perform bounds checking.
`static Color`	`directABGRF(float a, float b, float g, float r)` Directly create a color from alpha, blue, green and red values. This method does not perform bounds checking.
`static Color`	`directARGB(int a, int r, int g, int b)` Directly create a color from alpha, red, green and blue values. This method does not perform bounds checking.
`static Color`	`directARGBF(float a, float r, float g, float b)` Directly create a color from alpha, red, green and blue values. This method does not perform bounds checking.
`static Color`	`directBGR(int b, int g, int r)` Directly create a color from blue, green and red values. This method does not perform bounds checking.
`static Color`	`directBGRA(int b, int g, int r, int a)` Directly create a color from blue, green, red and alpha values. This method does not perform bounds checking.
`static Color`	`directBGRAF(float b, float g, float r, float a)` Directly create a color from blue, green, red and alpha values. This method does not perform bounds checking.
`static Color`	`directBGRF(float b, float g, float r)` Directly create a color from blue, green and red values. This method does not perform bounds checking.
`static Color`	`directRGB(int r, int g, int b)` Directly create a color from red, green and blue values. This method does not perform bounds checking.
`static Color`	`directRGBA(int r, int g, int b, int a)` Directly create a color from red, green, blue and alpha values. This method does not perform bounds checking.
`static Color`	`directRGBAF(float r, float g, float b, float a)` Directly create a color from red, green, blue and alpha values. This method does not perform bounds checking.
`static Color`	`directRGBF(float r, float g, float b)` Directly create a color from red, green and blue values. This method does not perform bounds checking.
`int`	`distance(Color color)` Calculate the distance between this color and another color.
`boolean`	`equals(java.lang.Object o)`
`static Color`	`fromABGR(int abgr)` Create a color from an int. The int must be in the format: 0xAABBGGRR
`static Color`	`fromABGR(int a, int b, int g, int r)` Create a color from alpha, blue, green and red values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromABGRF(float[] abgr)` Create a color from a float array. The array must have a length of 4. The array must contain the values in the order: a, b, g, r The values must be between 0 and 1 (inclusive).
`static Color`	`fromABGRF(float a, float b, float g, float r)` Create a color from alpha, blue, green and red values. The values must be between 0 and 1 (inclusive).
`static Color`	`fromARGB(int argb)` Create a color from an int. The int must be in the format: 0xAARRGGBB
`static Color`	`fromARGB(int a, int r, int g, int b)` Create a color from alpha, red, green and blue values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromARGBF(float[] argb)` Create a color from a float array. The array must have a length of 4. The array must contain the values in the order: a, r, g, b The values must be between 0 and 1 (inclusive).
`static Color`	`fromARGBF(float a, float r, float g, float b)` Create a color from alpha, red, green and blue values. The values must be between 0 and 1 (inclusive).
`static Color`	`fromAWT(java.awt.Color color)` Create a color from an AWT color. The alpha value will be included in the created color.
`static Color`	`fromBGR(int bgr)` Create a color from an int. The int must be in the format: 0xBBGGRR
`static Color`	`fromBGR(int b, int g, int r)` Create a color from blue, green and red values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromBGRA(int bgra)` Create a color from an int. The int must be in the format: 0xBBGGRRAA
`static Color`	`fromBGRA(int b, int g, int r, int a)` Create a color from blue, green, red and alpha values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromBGRAF(float[] bgra)` Create a color from a float array. The array must have a length of 4. The array must contain the values in the order: b, g, r, a The values must be between 0 and 1 (inclusive).
`static Color`	`fromBGRAF(float b, float g, float r, float a)` Create a color from blue, green, red and alpha values. The values must be between 0 and 1 (inclusive).
`static Color`	`fromBGRF(float[] bgr)` Create a color from a float array. The array must have a length of 3. The array must contain the values in the order: b, g, r The values must be between 0 and 1 (inclusive).
`static Color`	`fromBGRF(float b, float g, float r)` Create a color from blue, green and red values. The values must be between 0 and 1 (inclusive).
`static Color`	`fromHSB(float[] hsb)` Create a color from a float array. The array must have a length of 3. The array must contain the values in the order: h, s, b The values must be between 0 and 1 (inclusive).
`static Color`	`fromHSB(float hue, float saturation, float brightness)` Create a color from HSB values. The values must be between 0 and 1.
`static Color`	`fromRGB(int rgb)` Create a color from an int. The int must be in the format: 0xRRGGBB
`static Color`	`fromRGB(int r, int g, int b)` Create a color from red, green and blue values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromRGBA(int rgba)` Create a color from an int. The int must be in the format: 0xRRGGBBAA
`static Color`	`fromRGBA(int r, int g, int b, int a)` Create a color from red, green, blue and alpha values. The values must be between 0 and 255 (inclusive).
`static Color`	`fromRGBAF(float[] rgba)` Create a color from a float array. The array must have a length of 4. The array must contain the values in the order: r, g, b, a The values must be between 0 and 1 (inclusive).
`static Color`	`fromRGBAF(float r, float g, float b, float a)` Create a color from red, green, blue and alpha values. The values must be between 0 and 1 (inclusive).
`static Color`	`fromRGBF(float[] rgb)` Create a color from a float array. The array must have a length of 3. The array must contain the values in the order: r, g, b The values must be between 0 and 1 (inclusive).
`static Color`	`fromRGBF(float r, float g, float b)` Create a color from red, green and blue values. The values must be between 0 and 1 (inclusive).
`int`	`getAlpha()`
`float`	`getAlphaF()`
`int`	`getBlue()`
`float`	`getBlueF()`
`int`	`getGreen()`
`float`	`getGreenF()`
`static Color`	`getRainbowColor(int offset, float divider)` Get a color calculated by the current time. Calling this method subsequently will generate an RGB rainbow color effect. The offset depends on the used divider.
`int`	`getRed()`
`float`	`getRedF()`
`int`	`hashCode()`
`static Color`	`interpolate(float progress, Color... colors)` Interpolate between multiple colors with a progress. The progress is a value between 0 and 1. The colors must have a length greater than 0.
`static Color`	`interpolate(float progress, Color[] colors, float[] steps)` Interpolate between multiple colors with a progress. The progress is a value between 0 and 1. The colors and steps must have the same length.
`static Color`	`interpolate(float progress, Color color1, Color color2)` Interpolate between two colors with a progress. The progress is a value between 0 and 1.
`Color`	`invert()` Invert this color. The alpha value will not be changed.
`Color`	`multiply(Color color)` Multiply this color with another color. The values of this color will be multiplied with the float values of the other color.
`Color`	`multiply(float multiplier)` Multiply this color with a factor. The alpha value will not be changed.
`Color`	`multiplyAll(float multiplier)` Multiply this color with a factor.
`Color`	`multiplyAlpha(float multiplier)` Multiply this colors alpha value with a factor. The other values will not be changed.
`int`	`toABGR()`
`float[]`	`toABGRF()`
`int`	`toARGB()`
`float[]`	`toARGBF()`
`java.awt.Color`	`toAWT()`
`int`	`toBGR()`
`int`	`toBGRA()`
`float[]`	`toBGRAF()`
`float[]`	`toBGRF()`
`float[]`	`toHSB()`
`int`	`toRGB()`
`int`	`toRGBA()`
`float[]`	`toRGBAF()`
`float[]`	`toRGBF()`
`java.lang.String`	`toString()`
`Color`	`withAlpha(int a)` Get a new color with a different alpha value.
`Color`	`withAlphaF(float a)` Get a new color with a different alpha value.
`Color`	`withBlue(int b)` Get a new color with a different blue value.
`Color`	`withBlueF(float b)` Get a new color with a different blue value.
`Color`	`withGreen(int g)` Get a new color with a different green value.
`Color`	`withGreenF(float g)` Get a new color with a different green value.
`Color`	`withRed(int r)` Get a new color with a different red value.
`Color`	`withRedF(float r)` Get a new color with a different red value.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - TRANSPARENT
```
public static final Color TRANSPARENT
```
  - BLACK
```
public static final Color BLACK
```
  - LIGHT_GRAY
```
public static final Color LIGHT_GRAY
```
  - GRAY
```
public static final Color GRAY
```
  - DARK_GRAY
```
public static final Color DARK_GRAY
```
  - WHITE
```
public static final Color WHITE
```
  - RED
```
public static final Color RED
```
  - GREEN
```
public static final Color GREEN
```
  - BLUE
```
public static final Color BLUE
```
  - ORANGE
```
public static final Color ORANGE
```
  - YELLOW
```
public static final Color YELLOW
```
  - CYAN
```
public static final Color CYAN
```
  - PINK
```
public static final Color PINK
```
  - MAGENTA
```
public static final Color MAGENTA
```
- Method Detail
  - fromRGB
```
public static Color fromRGB(int rgb)
```
    Create a color from an int.
    The int must be in the format: 0xRRGGBB
    
    Parameters:
    
    rgb - The int
    
    Returns:
    
    The created color
  - fromRGB
```
public static Color fromRGB(int r,
                            int g,
                            int b)
```
    Create a color from red, green and blue values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - directRGB
```
public static Color directRGB(int r,
                              int g,
                              int b)
```
    Directly create a color from red, green and blue values.
    This method does not perform bounds checking.
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - fromRGBA
```
public static Color fromRGBA(int rgba)
```
    Create a color from an int.
    The int must be in the format: 0xRRGGBBAA
    
    Parameters:
    
    rgba - The int
    
    Returns:
    
    The created color
  - fromRGBA
```
public static Color fromRGBA(int r,
                             int g,
                             int b,
                             int a)
```
    Create a color from red, green, blue and alpha values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - directRGBA
```
public static Color directRGBA(int r,
                               int g,
                               int b,
                               int a)
```
    Directly create a color from red, green, blue and alpha values.
    This method does not perform bounds checking.
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - fromARGB
```
public static Color fromARGB(int argb)
```
    Create a color from an int.
    The int must be in the format: 0xAARRGGBB
    
    Parameters:
    
    argb - The int
    
    Returns:
    
    The created color
  - fromARGB
```
public static Color fromARGB(int a,
                             int r,
                             int g,
                             int b)
```
    Create a color from alpha, red, green and blue values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    a - The alpha value
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - directARGB
```
public static Color directARGB(int a,
                               int r,
                               int g,
                               int b)
```
    Directly create a color from alpha, red, green and blue values.
    This method does not perform bounds checking.
    
    Parameters:
    
    a - The alpha value
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - fromBGR
```
public static Color fromBGR(int bgr)
```
    Create a color from an int.
    The int must be in the format: 0xBBGGRR
    
    Parameters:
    
    bgr - The int
    
    Returns:
    
    The created color
  - fromBGR
```
public static Color fromBGR(int b,
                            int g,
                            int r)
```
    Create a color from blue, green and red values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - directBGR
```
public static Color directBGR(int b,
                              int g,
                              int r)
```
    Directly create a color from blue, green and red values.
    This method does not perform bounds checking.
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - fromBGRA
```
public static Color fromBGRA(int bgra)
```
    Create a color from an int.
    The int must be in the format: 0xBBGGRRAA
    
    Parameters:
    
    bgra - The int
    
    Returns:
    
    The created color
  - fromBGRA
```
public static Color fromBGRA(int b,
                             int g,
                             int r,
                             int a)
```
    Create a color from blue, green, red and alpha values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - directBGRA
```
public static Color directBGRA(int b,
                               int g,
                               int r,
                               int a)
```
    Directly create a color from blue, green, red and alpha values.
    This method does not perform bounds checking.
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - fromABGR
```
public static Color fromABGR(int abgr)
```
    Create a color from an int.
    The int must be in the format: 0xAABBGGRR
    
    Parameters:
    
    abgr - The int
    
    Returns:
    
    The created color
  - fromABGR
```
public static Color fromABGR(int a,
                             int b,
                             int g,
                             int r)
```
    Create a color from alpha, blue, green and red values.
    The values must be between 0 and 255 (inclusive).
    
    Parameters:
    
    a - The alpha value
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - directABGR
```
public static Color directABGR(int a,
                               int b,
                               int g,
                               int r)
```
    Directly create a color from alpha, blue, green and red values.
    This method does not perform bounds checking.
    
    Parameters:
    
    a - The alpha value
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - fromRGBF
```
public static Color fromRGBF(float[] rgb)
```
    Create a color from a float array.
    The array must have a length of 3.
    The array must contain the values in the order: r, g, b
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    rgb - The float array
    
    Returns:
    
    The created color
  - fromRGBF
```
public static Color fromRGBF(float r,
                             float g,
                             float b)
```
    Create a color from red, green and blue values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - directRGBF
```
public static Color directRGBF(float r,
                               float g,
                               float b)
```
    Directly create a color from red, green and blue values.
    This method does not perform bounds checking.
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - fromRGBAF
```
public static Color fromRGBAF(float[] rgba)
```
    Create a color from a float array.
    The array must have a length of 4.
    The array must contain the values in the order: r, g, b, a
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    rgba - The float array
    
    Returns:
    
    The created color
  - fromRGBAF
```
public static Color fromRGBAF(float r,
                              float g,
                              float b,
                              float a)
```
    Create a color from red, green, blue and alpha values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - directRGBAF
```
public static Color directRGBAF(float r,
                                float g,
                                float b,
                                float a)
```
    Directly create a color from red, green, blue and alpha values.
    This method does not perform bounds checking.
    
    Parameters:
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - fromARGBF
```
public static Color fromARGBF(float[] argb)
```
    Create a color from a float array.
    The array must have a length of 4.
    The array must contain the values in the order: a, r, g, b
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    argb - The float array
    
    Returns:
    
    The created color
  - fromARGBF
```
public static Color fromARGBF(float a,
                              float r,
                              float g,
                              float b)
```
    Create a color from alpha, red, green and blue values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    a - The alpha value
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - directARGBF
```
public static Color directARGBF(float a,
                                float r,
                                float g,
                                float b)
```
    Directly create a color from alpha, red, green and blue values.
    This method does not perform bounds checking.
    
    Parameters:
    
    a - The alpha value
    
    r - The red value
    
    g - The green value
    
    b - The blue value
    
    Returns:
    
    The created color
  - fromBGRF
```
public static Color fromBGRF(float[] bgr)
```
    Create a color from a float array.
    The array must have a length of 3.
    The array must contain the values in the order: b, g, r
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    bgr - The float array
    
    Returns:
    
    The created color
  - fromBGRF
```
public static Color fromBGRF(float b,
                             float g,
                             float r)
```
    Create a color from blue, green and red values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - directBGRF
```
public static Color directBGRF(float b,
                               float g,
                               float r)
```
    Directly create a color from blue, green and red values.
    This method does not perform bounds checking.
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - fromBGRAF
```
public static Color fromBGRAF(float[] bgra)
```
    Create a color from a float array.
    The array must have a length of 4.
    The array must contain the values in the order: b, g, r, a
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    bgra - The float array
    
    Returns:
    
    The created color
  - fromBGRAF
```
public static Color fromBGRAF(float b,
                              float g,
                              float r,
                              float a)
```
    Create a color from blue, green, red and alpha values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - directBGRAF
```
public static Color directBGRAF(float b,
                                float g,
                                float r,
                                float a)
```
    Directly create a color from blue, green, red and alpha values.
    This method does not perform bounds checking.
    
    Parameters:
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    a - The alpha value
    
    Returns:
    
    The created color
  - fromABGRF
```
public static Color fromABGRF(float[] abgr)
```
    Create a color from a float array.
    The array must have a length of 4.
    The array must contain the values in the order: a, b, g, r
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    abgr - The float array
    
    Returns:
    
    The created color
  - fromABGRF
```
public static Color fromABGRF(float a,
                              float b,
                              float g,
                              float r)
```
    Create a color from alpha, blue, green and red values.
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    a - The alpha value
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - directABGRF
```
public static Color directABGRF(float a,
                                float b,
                                float g,
                                float r)
```
    Directly create a color from alpha, blue, green and red values.
    This method does not perform bounds checking.
    
    Parameters:
    
    a - The alpha value
    
    b - The blue value
    
    g - The green value
    
    r - The red value
    
    Returns:
    
    The created color
  - fromHSB
```
public static Color fromHSB(float[] hsb)
```
    Create a color from a float array.
    The array must have a length of 3.
    The array must contain the values in the order: h, s, b
    The values must be between 0 and 1 (inclusive).
    
    Parameters:
    
    hsb - The float array
    
    Returns:
    
    The created color
  - fromHSB
```
public static Color fromHSB(float hue,
                            float saturation,
                            float brightness)
```
    Create a color from HSB values.
    The values must be between 0 and 1.
    
    Parameters:
    
    hue - The hue value
    
    saturation - The saturation value
    
    brightness - The brightness value
    
    Returns:
    
    The created color
  - fromAWT
```
public static Color fromAWT(java.awt.Color color)
```
    Create a color from an AWT color.
    The alpha value will be included in the created color.
    
    Parameters:
    
    color - The AWT color to convert
    
    Returns:
    
    The created color
  - getRainbowColor
```
public static Color getRainbowColor(int offset,
                                    float divider)
```
    Get a color calculated by the current time.
    Calling this method subsequently will generate an RGB rainbow color effect.
    The offset depends on the used divider. With a divider of 7.5F the color will be the same with the offset of 0 and 7500.
    The higher the divider the slower and smoother the color will change.
    
    Parameters:
    
    offset - The offset added to the current time
    
    divider - The divider for the current time
    
    Returns:
    
    The calculated color
    
    See Also:
    
    ColorUtils.getRainbowColor(int, float)
  - interpolate
```
public static Color interpolate(float progress,
                                Color color1,
                                Color color2)
```
    Interpolate between two colors with a progress.
    The progress is a value between 0 and 1.
    
    Parameters:
    
    progress - The progress between the two colors
    
    color1 - The first color
    
    color2 - The second color
    
    Returns:
    
    The interpolated color
    
    See Also:
    
    ColorUtils.interpolate(float, java.awt.Color, java.awt.Color)
  - interpolate
```
public static Color interpolate(float progress,
                                Color[] colors,
                                float[] steps)
```
    Interpolate between multiple colors with a progress.
    The progress is a value between 0 and 1.
    The colors and steps must have the same length.
    
    Parameters:
    
    progress - The progress between the colors
    
    colors - The colors to interpolate between
    
    steps - The steps between the colors
    
    Returns:
    
    The interpolated color
    
    See Also:
    
    ColorUtils.interpolate(float, java.awt.Color[], float[])
  - interpolate
```
public static Color interpolate(float progress,
                                Color... colors)
```
    Interpolate between multiple colors with a progress.
    The progress is a value between 0 and 1.
    The colors must have a length greater than 0.
    
    Parameters:
    
    progress - The progress between the colors
    
    colors - The colors to interpolate between
    
    Returns:
    
    The interpolated color
    
    See Also:
    
    ColorUtils.interpolate(float, java.awt.Color...)
  - getRed
```
public int getRed()
```
    Returns:
    
    The red value between 0 and 255
  - getRedF
```
public float getRedF()
```
    Returns:
    
    The red value between 0 and 1
  - withRed
```
public Color withRed(int r)
```
    Get a new color with a different red value.
    
    Parameters:
    
    r - The new red value between 0 and 255
    
    Returns:
    
    The new color
  - withRedF
```
public Color withRedF(float r)
```
    Get a new color with a different red value.
    
    Parameters:
    
    r - The new red value between 0 and 1
    
    Returns:
    
    The new color
  - getGreen
```
public int getGreen()
```
    Returns:
    
    The green value between 0 and 255
  - getGreenF
```
public float getGreenF()
```
    Returns:
    
    The green value between 0 and 1
  - withGreen
```
public Color withGreen(int g)
```
    Get a new color with a different green value.
    
    Parameters:
    
    g - The new green value between 0 and 255
    
    Returns:
    
    The new color
  - withGreenF
```
public Color withGreenF(float g)
```
    Get a new color with a different green value.
    
    Parameters:
    
    g - The new green value between 0 and 1
    
    Returns:
    
    The new color
  - getBlue
```
public int getBlue()
```
    Returns:
    
    The blue value between 0 and 255
  - getBlueF
```
public float getBlueF()
```
    Returns:
    
    The blue value between 0 and 1
  - withBlue
```
public Color withBlue(int b)
```
    Get a new color with a different blue value.
    
    Parameters:
    
    b - The new blue value between 0 and 255
    
    Returns:
    
    The new color
  - withBlueF
```
public Color withBlueF(float b)
```
    Get a new color with a different blue value.
    
    Parameters:
    
    b - The new blue value between 0 and 1
    
    Returns:
    
    The new color
  - getAlpha
```
public int getAlpha()
```
    Returns:
    
    The alpha value between 0 and 255
  - getAlphaF
```
public float getAlphaF()
```
    Returns:
    
    The alpha value between 0 and 1
  - withAlpha
```
public Color withAlpha(int a)
```
    Get a new color with a different alpha value.
    
    Parameters:
    
    a - The new alpha value between 0 and 255
    
    Returns:
    
    The new color
  - withAlphaF
```
public Color withAlphaF(float a)
```
    Get a new color with a different alpha value.
    
    Parameters:
    
    a - The new alpha value between 0 and 1
    
    Returns:
    
    The new color
  - toRGB
```
public int toRGB()
```
    Returns:
    
    The color as an int in the format: 0xRRGGBB
  - toRGBF
```
public float[] toRGBF()
```
    Returns:
    
    The color as a float array with the values in the order: r, g, b
  - toRGBA
```
public int toRGBA()
```
    Returns:
    
    The color as an int in the format: 0xRRGGBBAA
  - toRGBAF
```
public float[] toRGBAF()
```
    Returns:
    
    The color as a float array with the values in the order: r, g, b, a
  - toARGB
```
public int toARGB()
```
    Returns:
    
    The color as an int in the format: 0xAARRGGBB
  - toARGBF
```
public float[] toARGBF()
```
    Returns:
    
    The color as a float array with the values in the order: a, r, g, b
  - toBGR
```
public int toBGR()
```
    Returns:
    
    The color as an int in the format: 0xBBGGRR
  - toBGRF
```
public float[] toBGRF()
```
    Returns:
    
    The color as a float array with the values in the order: b, g, r
  - toBGRA
```
public int toBGRA()
```
    Returns:
    
    The color as an int in the format: 0xBBGGRRAA
  - toBGRAF
```
public float[] toBGRAF()
```
    Returns:
    
    The color as a float array with the values in the order: b, g, r, a
  - toABGR
```
public int toABGR()
```
    Returns:
    
    The color as an int in the format: 0xAABBGGRR
  - toABGRF
```
public float[] toABGRF()
```
    Returns:
    
    The color as a float array with the values in the order: a, b, g, r
  - toHSB
```
public float[] toHSB()
```
    Returns:
    
    The color as a float array with the values in the order: h, s, b
  - toAWT
```
public java.awt.Color toAWT()
```
    Returns:
    
    The color as an AWT color
  - brighter
```
public Color brighter()
```
    Returns:
    
    This color brightened by 0.7
  - brighter
```
public Color brighter(float factor)
```
    Brighten this color by the given factor.
    
    Parameters:
    
    factor - The factor to brighten this color by
    
    Returns:
    
    The new color
  - darker
```
public Color darker()
```
    Returns:
    
    This color darkened by 0.7
  - darker
```
public Color darker(float factor)
```
    Darken this color by the given factor.
    
    Parameters:
    
    factor - The factor to darken this color by
    
    Returns:
    
    The new color
  - invert
```
public Color invert()
```
    Invert this color.
    The alpha value will not be changed.
    
    Returns:
    
    The inverted color
  - multiply
```
public Color multiply(float multiplier)
```
    Multiply this color with a factor.
    The alpha value will not be changed.
    
    Parameters:
    
    multiplier - The factor to multiply with
    
    Returns:
    
    The multiplied color
  - multiplyAlpha
```
public Color multiplyAlpha(float multiplier)
```
    Multiply this colors alpha value with a factor.
    The other values will not be changed.
    
    Parameters:
    
    multiplier - The factor to multiply with
    
    Returns:
    
    The multiplied color
  - multiplyAll
```
public Color multiplyAll(float multiplier)
```
    Multiply this color with a factor.
    
    Parameters:
    
    multiplier - The factor to multiply with
    
    Returns:
    
    The multiplied color
  - multiply
```
public Color multiply(Color color)
```
    Multiply this color with another color.
    The values of this color will be multiplied with the float values of the other color.
    
    Parameters:
    
    color - The color to multiply with
    
    Returns:
    
    The multiplied color
  - distance
```
public int distance(Color color)
```
    Calculate the distance between this color and another color.
    
    Parameters:
    
    color - The other color
    
    Returns:
    
    The distance between the colors
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object

Class Color

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TRANSPARENT

BLACK

LIGHT_GRAY

GRAY

DARK_GRAY

WHITE

RED

GREEN

BLUE

ORANGE

YELLOW

CYAN

PINK

MAGENTA

Method Detail

fromRGB

fromRGB

directRGB

fromRGBA

fromRGBA

directRGBA

fromARGB

fromARGB

directARGB

fromBGR

fromBGR

directBGR

fromBGRA

fromBGRA

directBGRA

fromABGR

fromABGR

directABGR

fromRGBF

fromRGBF

directRGBF

fromRGBAF

fromRGBAF

directRGBAF

fromARGBF

fromARGBF

directARGBF

fromBGRF

fromBGRF

directBGRF

fromBGRAF

fromBGRAF

directBGRAF

fromABGRF

fromABGRF

directABGRF

fromHSB

fromHSB

fromAWT

getRainbowColor

interpolate

interpolate

interpolate

getRed

getRedF

withRed

withRedF

getGreen

getGreenF

withGreen

withGreenF

getBlue

getBlueF

withBlue

withBlueF

getAlpha

getAlphaF

withAlpha

withAlphaF

toRGB