squidpony

Class IColorCenter.Skeleton<T>

java.lang.Object

squidpony.IColorCenter.Skeleton<T>

Type Parameters:

T - a concrete color type

All Implemented Interfaces:

IColorCenter<T>

Enclosing interface:

IColorCenter<T>

public abstract static class IColorCenter.Skeleton<T>
extends java.lang.Object
implements IColorCenter<T>

A skeletal implementation of IColorCenter.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	IColorCenter.Skeleton.GranularHasher

Nested classes/interfaces inherited from interface squidpony.IColorCenter

IColorCenter.Skeleton<T>

Field Summary

Fields

Modifier and Type	Field and Description
protected IFilter<T>	filter
protected IColorCenter.Skeleton.GranularHasher	theHasher

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Skeleton(IFilter<T> filter)

Method Summary

Modifier and Type	Method and Description
int	cacheSize() The actual cache is not public, but there are cases where you may want to know how many different colors are actually used in a frame or a section of the game.
void	clearCache() It clears the cache.
void	copyCache(IColorCenter.Skeleton<T> other) You may want to copy colors between IColorCenter instances that have different create() methods -- and as such, will have different values for the same keys in the cache.
protected abstract T	create(int red, int green, int blue, int opacity) Create a concrete instance of the color type given as a type parameter.
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)
T	getBlack()
T	getHSV(float hue, float saturation, float value)
T	getHSV(float hue, float saturation, float value, float opacity)
float	getHue(float r, float g, float b)
float	getHue(T c)
T	getRandom(IRNG rng, int opacity)
float	getSaturation(float r, float g, float b)
float	getSaturation(T c)
T	getTransparent()
protected long	getUniqueIdentifier(int r, int g, int b, int a)
protected long	getUniqueIdentifier(T item)
float	getValue(float r, float g, float b)
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.
IColorCenter.Skeleton<T>	setFilter(IFilter<T> filter) If you're changing the filter, you should likely call clearCache().

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface squidpony.IColorCenter

getAlpha, getBlue, getGreen, getRed

Field Detail

theHasher

protected IColorCenter.Skeleton.GranularHasher theHasher

filter

protected IFilter<T> filter

Constructor Detail

Skeleton

protected Skeleton(IFilter<T> filter)

Parameters:

filter - The filter to use, or null for no filter.

Method Detail

clearCache

public void clearCache()

It clears the cache. You may need to do this to limit the cache to the colors used in a specific section. This is also useful if a Filter changes what colors it should return on a frame-by-frame basis; in that case, you can call clearCache() at the start or end of a frame to ensure the next frame gets different colors.

cacheSize

public int cacheSize()

The actual cache is not public, but there are cases where you may want to know how many different colors are actually used in a frame or a section of the game. If the cache was emptied (which might be from calling clearCache()), some colors were requested, then this is called, the returned int should be the count of distinct colors this IColorCenter had created and cached; duplicates won't be counted twice.

Returns:

copyCache

public void copyCache(IColorCenter.Skeleton<T> other)

You may want to copy colors between IColorCenter instances that have different create() methods -- and as such, will have different values for the same keys in the cache. This allows you to copy the cache from other into this Skeleton, but using this Skeleton's create() method.

Parameters:

other - another Skeleton of the same type that will have its cache copied into this Skeleton

setFilter

public IColorCenter.Skeleton<T> setFilter(IFilter<T> filter)

If you're changing the filter, you should likely call clearCache().

Parameters:

filter - The filter to use, or null to turn filtering OFF.

Returns:

this

get

public T get(int red,
             int green,
             int blue,
             int opacity)

Specified by:

get in interface IColorCenter<T>

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

public T get(int red,
             int green,
             int blue)

Specified by:

get in interface IColorCenter<T>

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

public T getHSV(float hue,
                float saturation,
                float value,
                float opacity)

Specified by:

getHSV in interface IColorCenter<T>

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

public T getHSV(float hue,
                float saturation,
                float value)

Specified by:

getHSV in interface IColorCenter<T>

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

public T getWhite()

Specified by:

getWhite in interface IColorCenter<T>

Returns:

Opaque white.

getBlack

public T getBlack()

Specified by:

getBlack in interface IColorCenter<T>

Returns:

Opaque black.

getTransparent

public T getTransparent()

Specified by:

getTransparent in interface IColorCenter<T>

Returns:

The fully transparent color.

getRandom

public T getRandom(IRNG rng,
                   int opacity)

Specified by:

getRandom in interface IColorCenter<T>

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.

getSaturation

public float getSaturation(float r,
                           float g,
                           float b)

Parameters:

r - the red component in 0.0 to 1.0 range, typically

g - the green component in 0.0 to 1.0 range, typically

b - the blue component in 0.0 to 1.0 range, typically

Returns:

the saturation of the color from 0.0 (a grayscale color; inclusive) to 1.0 (a bright color, exclusive)

getSaturation

public float getSaturation(T c)

Specified by:

getSaturation in interface IColorCenter<T>

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

public float getValue(float r,
                      float g,
                      float b)

Parameters:

r - the red component in 0.0 to 1.0 range, typically

g - the green component in 0.0 to 1.0 range, typically

b - the blue component in 0.0 to 1.0 range, typically

Returns:

the value (essentially lightness) of the color from 0.0 (black, inclusive) to 1.0 (very bright, inclusive).

getValue

public float getValue(T c)

Specified by:

getValue in interface IColorCenter<T>

Parameters:

c - a concrete color

Returns:

the value (essentially lightness) of the color from 0.0 (black, inclusive) to 1.0 (very bright, inclusive).

getHue

public float getHue(float r,
                    float g,
                    float b)

Parameters:

r - the red component in 0.0 to 1.0 range, typically

g - the green component in 0.0 to 1.0 range, typically

b - the blue component in 0.0 to 1.0 range, typically

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)

getHue

public float getHue(T c)

Specified by:

getHue in interface IColorCenter<T>

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)

filter

public T filter(T c)

Specified by:

filter in interface IColorCenter<T>

Returns:

The color that this shows when c is requested. May be c itself.

filter

public IColoredString<T> filter(IColoredString<T> ics)

Specified by:

filter in interface IColorCenter<T>

Returns:

ics filtered according to IColorCenter.filter(Object). May be ics itself if unchanged.

greify

public 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."

Specified by:

greify in interface IColorCenter<T>

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

public 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. This implementation tries to work with colors in a way that is as general as possible, using getRed() instead of some specific detail that depends on how a color is implemented. Other implementations that specialize in a specific type of color may be able to be more efficient.

Specified by:

lerp in interface IColorCenter<T>

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

public 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.

Specified by:

desaturated in interface IColorCenter<T>

Parameters:

color - the color T to desaturate (will not be modified)

Returns:

the grayscale version of color

desaturate

public 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.

Specified by:

desaturate in interface IColorCenter<T>

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

public 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.

Specified by:

saturated in interface IColorCenter<T>

Parameters:

color - the color T to saturate (will not be modified)

Returns:

the saturated version of color

saturate

public 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 is likely to produce a red hue by default (if there's no hue to make vivid, it needs to choose something).

Specified by:

saturate in interface IColorCenter<T>

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

public java.util.ArrayList<T> gradient(T fromColor,
                                       T toColor)

Description copied from interface: IColorCenter

Finds a gradient with 16 steps going from fromColor to toColor, both included in the gradient.

Specified by:

gradient in interface IColorCenter<T>

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

public java.util.ArrayList<T> gradient(T fromColor,
                                       T toColor,
                                       int steps)

Description copied from interface: IColorCenter

Finds a gradient with the specified number of steps going from fromColor to toColor, both included in the gradient.

Specified by:

gradient in interface IColorCenter<T>

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

create

protected abstract T create(int red,
                            int green,
                            int blue,
                            int opacity)

Create a concrete instance of the color type given as a type parameter. That's the place to use the filter.

Parameters:

red - the red component of the desired color

green - the green component of the desired color

blue - the blue component of the desired color

opacity - the alpha component or opacity of the desired color

Returns:

a fresh instance of the concrete color type

getUniqueIdentifier

protected long getUniqueIdentifier(int r,
                                   int g,
                                   int b,
                                   int a)

getUniqueIdentifier

protected long getUniqueIdentifier(T item)