IColorCenter (squidlib-util 3.0.6 API)

Type Parameters:

T - The concrete type of colors

All Known Implementing Classes:

IColorCenter.Skeleton
```
public interface IColorCenter<T>
```
How to manage colors, making sure that a color is allocated at most once.
If you aren't using squidlib's gdx part, you should use this interface (and the IColorCenter.Skeleton implementation), because it caches instances.

If you are using squidlib's gdx part, you should use this interface (and the SquidColorCenter implementation) if:
- You don't want to use preallocated instances (if you do, check out squidpony.squidgrid.gui.Colors)
- You don't want to use named colors (if you do, check out com.badlogic.gdx.graphics.Colors)
- You don't like libgdx's Color representation (components as floats in-between 0 and 1) but prefer components within 0 (inclusive) and 256 (exclusive); and don't mind the overhead of switching the representations. My personal opinion is that the overhead doesn't matter w.r.t other intensive operations that we have in roguelikes (path finding).

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class IColorCenter.Skeleton<T>
A skeletal implementation of IColorCenter.

Nested Classes
Modifier and Type	Interface and Description
`static class`	`IColorCenter.Skeleton<T>` A skeletal implementation of `IColorCenter`.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`T`	`desaturate(T color, float degree)` Brings a color closer to grayscale by the specified degree and returns the new color (desaturated somewhat).
`T`	`desaturated(T color)` Gets a fully-desaturated version of the given color (keeping its brightness, but making it grayscale).
`IColoredString<T>`	`filter(IColoredString<T> ics)`
`T`	`filter(T c)`
`T`	`get(int red, int green, int blue)`
`T`	`get(int red, int green, int blue, int opacity)`
`int`	`getAlpha(T c)`
`T`	`getBlack()`
`int`	`getBlue(T c)`
`int`	`getGreen(T c)`
`T`	`getHSV(float hue, float saturation, float value)`
`T`	`getHSV(float hue, float saturation, float value, float opacity)`
`float`	`getHue(T c)`
`T`	`getRandom(IRNG rng, int opacity)`
`int`	`getRed(T c)`
`float`	`getSaturation(T c)`
`T`	`getTransparent()`
`float`	`getValue(T c)`
`T`	`getWhite()`
`java.util.ArrayList<T>`	`gradient(T fromColor, T toColor)` Finds a gradient with 16 steps going from fromColor to toColor, both included in the gradient.
`java.util.ArrayList<T>`	`gradient(T fromColor, T toColor, int steps)` Finds a gradient with the specified number of steps going from fromColor to toColor, both included in the gradient.
`T`	`greify(T t, boolean doAlpha)` Gets a copy of t and modifies it to make a shade of gray with the same brightness.
`T`	`lerp(T start, T end, float change)` Gets the linear interpolation from Color start to Color end, changing by the fraction given by change.
`T`	`saturate(T color, float degree)` Saturates color (makes it closer to a vivid color like red or green and less gray) by the specified degree and returns the new color (saturated somewhat).
`T`	`saturated(T color)` Fully saturates color (makes it a vivid color like red or green and less gray) and returns the modified copy.

- Method Detail
  - get
```
T get(int red,
      int green,
      int blue,
      int opacity)
```
    Parameters:
    
    red - The red component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    green - The green component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    blue - The blue component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    opacity - The alpha component. In-between 0 (inclusive) and 256 (exclusive). Larger values mean more opacity; 0 is clear.
    
    Returns:
    
    A possibly transparent color.
  - get
```
T get(int red,
      int green,
      int blue)
```
    Parameters:
    
    red - The red component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    green - The green component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    blue - The blue component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
    
    Returns:
    
    An opaque color.
  - getHSV
```
T getHSV(float hue,
         float saturation,
         float value,
         float opacity)
```
    Parameters:
    
    hue - The hue of the desired color from 0.0 (red, inclusive) towards orange, then yellow, and eventually to purple before looping back to almost the same red (1.0, exclusive). Values outside this range should be treated as wrapping around, so 1.1f and -0.9f would be the same as 0.1f .
    
    saturation - the saturation of the color from 0.0 (a grayscale color; inclusive) to 1.0 (a bright color, inclusive)
    
    value - the value (essentially lightness) of the color from 0.0 (black, inclusive) to 1.0 (very bright, inclusive).
    
    opacity - the alpha component as a float; 0.0f is clear, 1.0f is opaque.
    
    Returns:
    
    a possibly transparent color
  - getHSV
```
T getHSV(float hue,
         float saturation,
         float value)
```
    Parameters:
    
    hue - The hue of the desired color from 0.0 (red, inclusive) towards orange, then yellow, and eventually to purple before looping back to almost the same red (1.0, exclusive)
    
    saturation - the saturation of the color from 0.0 (a grayscale color; inclusive) to 1.0 (a bright color, exclusive)
    
    value - the value (essentially lightness) of the color from 0.0 (black, inclusive) to 1.0 (very bright, inclusive).
    
    Returns:
    
    an opaque color
  - getWhite
```
T getWhite()
```
    Returns:
    
    Opaque white.
  - getBlack
```
T getBlack()
```
    Returns:
    
    Opaque black.
  - getTransparent
```
T getTransparent()
```
    Returns:
    
    The fully transparent color.
  - getRandom
```
T getRandom(IRNG rng,
            int opacity)
```
    Parameters:
    
    rng - an RNG from SquidLib.
    
    opacity - The alpha component. In-between 0 (inclusive) and 256 (exclusive). Larger values mean more opacity; 0 is clear.
    
    Returns:
    
    A random color, except for the alpha component.
  - getRed
```
int getRed(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    The red component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
  - getGreen
```
int getGreen(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    The green component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
  - getBlue
```
int getBlue(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    The blue component. For screen colors, in-between 0 (inclusive) and 256 (exclusive).
  - getAlpha
```
int getAlpha(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    The alpha component. In-between 0 (inclusive) and 256 (exclusive).
  - getHue
```
float getHue(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    The hue of the color from 0.0 (red, inclusive) towards orange, then yellow, and eventually to purple before looping back to almost the same red (1.0, exclusive)
  - getSaturation
```
float getSaturation(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    the saturation of the color from 0.0 (a grayscale color; inclusive) to 1.0 (a bright color, exclusive)
  - getValue
```
float getValue(T c)
```
    Parameters:
    
    c - a concrete color
    
    Returns:
    
    the value (essentially lightness) of the color from 0.0 (black, inclusive) to 1.0 (very bright, inclusive).
  - filter
```
T filter(T c)
```
    Parameters:
    
    c -
    
    Returns:
    
    The color that this shows when c is requested. May be c itself.
  - filter
```
IColoredString<T> filter(IColoredString<T> ics)
```
    Parameters:
    
    ics -
    
    Returns:
    
    ics filtered according to filter(Object). May be ics itself if unchanged.
  - greify
```
T greify(T t,
         boolean doAlpha)
```
    Gets a copy of t and modifies it to make a shade of gray with the same brightness. The doAlpha parameter causes the alpha to be considered in the calculation of brightness and also changes the returned alpha of the color. Not related to reified types or any usage of "reify."
    
    Parameters:
    
    t - a T to copy; only the copy will be modified
    
    doAlpha - Whether to include (and hereby change) the alpha component.
    
    Returns:
    
    A monochromatic variation of t.
  - lerp
```
T lerp(T start,
       T end,
       float change)
```
    Gets the linear interpolation from Color start to Color end, changing by the fraction given by change.
    
    Parameters:
    
    start - the initial color T
    
    end - the "target" color T
    
    change - the degree to change closer to end; a change of 0.0f produces start, 1.0f produces end
    
    Returns:
    
    a new T between start and end
  - desaturated
```
T desaturated(T color)
```
    Gets a fully-desaturated version of the given color (keeping its brightness, but making it grayscale). Keeps alpha the same; if you want alpha to be considered (and brightness to be calculated differently), then you can use greify() in this class instead.
    
    Parameters:
    
    color - the color T to desaturate (will not be modified)
    
    Returns:
    
    the grayscale version of color
  - desaturate
```
T desaturate(T color,
             float degree)
```
    Brings a color closer to grayscale by the specified degree and returns the new color (desaturated somewhat). Alpha is left unchanged.
    
    Parameters:
    
    color - the color T to desaturate
    
    degree - a float between 0.0f and 1.0f; more makes it less colorful
    
    Returns:
    
    the desaturated (and if a filter is used, also filtered) new color T
  - saturated
```
T saturated(T color)
```
    Fully saturates color (makes it a vivid color like red or green and less gray) and returns the modified copy. Leaves alpha unchanged.
    
    Parameters:
    
    color - the color T to saturate (will not be modified)
    
    Returns:
    
    the saturated version of color
  - saturate
```
T saturate(T color,
           float degree)
```
    Saturates color (makes it closer to a vivid color like red or green and less gray) by the specified degree and returns the new color (saturated somewhat). If this is called on a color that is very close to gray, this does not necessarily return a specific color, but most implementations will treat a hue of 0 as red.
    
    Parameters:
    
    color - the color T to saturate
    
    degree - a float between 0.0f and 1.0f; more makes it more colorful
    
    Returns:
    
    the saturated (and if a filter is used, also filtered) new color
  - gradient
```
java.util.ArrayList<T> gradient(T fromColor,
                                T toColor)
```
    Finds a gradient with 16 steps going from fromColor to toColor, both included in the gradient.
    
    Parameters:
    
    fromColor - the color to start with, included in the gradient
    
    toColor - the color to end on, included in the gradient
    
    Returns:
    
    an ArrayList composed of the blending steps from fromColor to toColor, with length equal to steps
  - gradient
```
java.util.ArrayList<T> gradient(T fromColor,
                                T toColor,
                                int steps)
```
    Finds a gradient with the specified number of steps going from fromColor to toColor, both included in the gradient.
    
    Parameters:
    
    fromColor - the color to start with, included in the gradient
    
    toColor - the color to end on, included in the gradient
    
    steps - the number of elements to use in the gradient
    
    Returns:
    
    an ArrayList composed of the blending steps from fromColor to toColor, with length equal to steps

Interface IColorCenter<T>

Nested Class Summary

Method Summary

Method Detail

get

get

getHSV

getHSV

getWhite

getBlack

getTransparent

getRandom

getRed

getGreen

getBlue

getAlpha

getHue

getSaturation

getValue

filter

filter

greify

lerp

desaturated

desaturate

saturated

saturate

gradient

gradient