Class TCODColor

• Defined in File color.hpp

Class Documentation

class TCODColor

The Doryen library uses 32bits colors. Thus, your OS desktop must use 32bits colors. A color is defined by its red, green and blue component between 0 and 255. You can use the following predefined colors (hover over a color to see its full name and R,G,B values):

TCODColor::desaturatedRed TCODColor::lightestRed TCODColor::lighterRed TCODColor::lightRed TCODColor::red TCODColor::darkRed TCODColor::darkerRed TCODColor::darkestRed

TCOD_desaturated_red TCOD_lightest_red TCOD_lighter_red TCOD_light_red TCOD_red TCOD_dark_red TCOD_darker_red TCOD_darkest_red

libtcod.desaturated_red libtcod.lightest_red libtcod.lighter_red libtcod.light_red libtcod.red libtcod.dark_red libtcod.darker_red libtcod.darkest_red

TCODColor::desaturatedRed TCODColor::lightestRed TCODColor::lighterRed TCODColor::lightRed TCODColor::red TCODColor::darkRed TCODColor::darkerRed TCODColor::darkestRed

tcod.color.desaturatedRed tcod.color.lightestRed tcod.color.lighterRed tcod.color.lightRed tcod.color.red tcod.color.darkRed tcod.color.darkerRed tcod.color.darkestRed

Public Functions

constexpr TCODColor() noexcept = default

inline constexpr TCODColor(uint8_t r_, uint8_t g_, uint8_t b_) noexcept

You can create your own colours using a set of constructors, both for RGB and HSV values.

TCODColor myColor(24,64,255); //RGB TCODColor myOtherColor(321.0f,0.7f,1.0f); //HSV

TCOD_color_t my_color={24,64,255}; /* RGB */ TCOD_color_t my_other_color = TCOD_color_RGB(24,64,255); /* RGB too */ TCOD_color_t my_yet_another_color = TCOD_color_HSV(321.0f,0.7f,1.0f); /* HSV */

TCODColor myColor = new TCODColor(321.0f,0.7f,1.0f); //HSV

inline constexpr TCODColor(int r_, int g_, int b_) noexcept

inline constexpr TCODColor(const TCOD_color_t &col) noexcept

TCODColor(float h, float s, float v) noexcept

inline constexpr bool operator==(const TCODColor &c) const noexcept

if (myColor == TCODColor::yellow) { …

} if (myColor != TCODColor::white) { … }

if (TCOD_color_equals(my_color,TCOD_yellow)) { … } if (!TCOD_color_equals(my_color,TCOD_white)) { … }

if my_color == libtcod.yellow : … if my_color != libtcod.white : …

if (myColor.Equal(TCODColor.yellow)) { … } if (myColor.NotEqual(TCODColor.white)) { … }

if myColor == tcod.color.yellow then … end

inline constexpr bool operator!=(const TCODColor &c) const noexcept

inline constexpr TCODColor operator*(const TCODColor &rhs) const noexcept

c1 = c2 * c3 => c1.r = c2.r * c3.r / 255 c1.g = c2.g * c3.g / 255 c1.b = c2.b * c3.b / 255 darkishRed = darkGrey * red

inline constexpr TCODColor operator*(float value) const noexcept

c1 = c2 * v => c1.r = CLAMP(0, 255, c2.r * v) c1.g = CLAMP(0, 255, c2.g * v) c1.b = CLAMP(0, 255, c2.b * v) darkishRed = red * 0.5

</tbody>

inline constexpr TCODColor operator+(const TCODColor &rhs) const noexcept

c1 = c1 + c2 => c1.r = MIN(255, c1.r + c2.r) c1.g = MIN(255, c1.g + c2.g) c1.b = MIN(255, c1.b + c2.b) lightishRed = red + darkGrey

inline constexpr TCODColor operator-(const TCODColor &rhs) const noexcept

c1 = c1 - c2 => c1.r = MAX(0, c1.r - c2.r) c1.g = MAX(0, c1.g - c2.g) c1.b = MAX(0, c1.b - c2.b) redish = red - darkGrey

void setHSV(float h, float s, float v) noexcept

After this function is called, the r,g,b fields of the color are calculated according to the h,s,v parameters.

Parameters

• c – In the C and Python versions, the color to modify

• h, s, v – Color components in the HSV space 0.0 <= h < 360.0 0.0 <= s <= 1.0 0.0 <= v <= 1.0

void setHue(float h) noexcept

These functions set only a single component in the HSV color space.

void TCODColor::setHue (float h) void TCODColor::setSaturation (float s) void TCODColor::setValue (float v)

void TCOD_color_set_hue (TCOD_color_t *c, float h) void TCOD_color_set_saturation (TCOD_color_t *c, float s) void TCOD_color_set_value (TCOD_color_t *c, float v)

Color:setHue(h) Color:setSaturation(s) Color:setValue(v)

Parameters

• h, s, v – Color components in the HSV space

• c – In the C and Python versions, the color to modify

void setSaturation(float s) noexcept

void setValue(float v) noexcept

void getHSV(float *h, float *s, float *v) const noexcept

Parameters

• c – In the C and Python versions, the TCOD_color_t from which to read.

• h, s, v – Color components in the HSV space 0.0 <= h < 360.0 0.0 <= s <= 1.0 0.0 <= v <= 1.0

float getHue() noexcept

Should you need to extract only one of the HSV components, these functions are what you should call.

Note that if you need all three values, it’s way less burdensome for the CPU to call TCODColor::getHSV().

float TCODColor::getHue () float TCODColor::getSaturation () float TCODColor::getValue ()

float TCOD_color_get_hue (TCOD_color_t c) float TCOD_color_get_saturation (TCOD_color_t c) float TCOD_color_get_value (TCOD_color_t c)

Color:getHue() Color:getSaturation() Color:getValue()

float TCODColor::getHue() float TCODColor::getSaturation() float TCODColor::getValue()

Parameters

c – the TCOD_color_t from which to read

float getSaturation() noexcept

float getValue() noexcept

void shiftHue(float hshift) noexcept

The hue shift value is the number of grades the color’s hue will be shifted.

The value can be negative for shift left, or positive for shift right. Resulting values H < 0 and H >= 360 are handled automatically.

Parameters

• c – The color to modify

• hshift – The hue shift value

void scaleHSV(float sscale, float vscale) noexcept

Parameters

• c – The color to modify

• sscale – saturation multiplier (1.0f for no change)

• vscale – value multiplier (1.0f for no change)

inline explicit constexpr operator TCOD_ColorRGB() const noexcept

Allow explicit conversions to TCOD_ColorRGB.

New in version 1.19.

inline explicit constexpr operator TCOD_ColorRGBA() const noexcept

Allow explicit conversions to TCOD_ColorRGBA.

New in version 1.19.

inline explicit constexpr operator tcod::ColorRGB() const noexcept

Allow explicit conversions to tcod::ColorRGB.

New in version 1.19.

inline explicit constexpr operator tcod::ColorRGBA() const noexcept

Allow explicit conversions to tcod::ColorRGBA.

New in version 1.19.

Public Members

uint8_t r = {}

uint8_t g = {}

uint8_t b = {}

Public Static Functions

static inline constexpr TCODColor lerp(const TCODColor &c1, const TCODColor &c2, float coef) noexcept

c1 = lerp (c2, c3, coef) => c1.r = c2.r + (c3.r - c2.r ) * coef c1.g = c2.g + (c3.g - c2.g ) * coef c1.b = c2.b + (c3.b - c2.b ) * coef coef should be between 0.0 and 1.0 but you can as well use other values

coef == 0.0f
coef == 0.25f
coef == 0.5f
coef == 0.75f
coef == 1.0f

static void genMap(TCODColor *map, int nbKey, TCODColor const *keyColor, int const *keyIndex)

You can define a color map from an array of color keys.

Colors will be interpolated between the keys. 0 -> black 4 -> red 8 -> white Result :

black

red

white </tbody>

int idx[] = { 0, 4, 8 }; // indexes of the keys TCODColor col[] = { TCODColor( 0,0,0 ), TCODColor(255,0,0), TCODColor(255,255,255) }; // colors : black, red, white TCODColor map[9]; TCODColor::genMap(map,3,col,idx);

int idx[] = { 0, 4, 8 }; // indexes of the keys TCOD_color_t col[] = { { 0,0,0 }, {255,0,0}, {255,255,255} }; // colors : black, red, white TCOD_color_t map[9]; TCOD_color_gen_map(map,3,col,idx);

idx = [ 0, 4, 8 ] # indexes of the keys col = [ libtcod.Color( 0,0,0 ), libtcod.Color( 255,0,0 ), libtcod.Color(255,255,255) ] # colors : black, red, white map=libtcod.color_gen_map(col,idx)

Parameters

• map – An array of colors to be filled by the function.

• nbKey – Number of color keys

• keyColor – Array of nbKey colors containing the color of each key

• keyIndex – Array of nbKey integers containing the index of each key. If you want to fill the map array, keyIndex[0] must be 0 and keyIndex[nbKey-1] is the number of elements in map minus 1 but you can also use the function to fill only a part of the map array.

template<int OutSize, typename KeyColors, typename KeyIndexes>
static inline constexpr auto genMap(const KeyColors &key_colors, const KeyIndexes &key_indexes) -> std::array<tcod::ColorRGB, OutSize>

Generate a gradient of colors.

// Generate an array of 16 colors, with black=0, red=8, white=15.
static constexpr auto gradient = TCODColor::genMap<16>(
    std::array{tcod::ColorRGB{0, 0, 0}, tcod::ColorRGB{255, 0, 0}, tcod::ColorRGB{255, 255, 255}},
    std::array{0, 8, 15});

New in version 1.24.

Template Parameters

• OutSize – The size of the output array.

• KeyColors – A key color container of tcod::ColorRGB-like objects.

• KeyIndexes – The key index container of integers.

Parameters

• key_colors – An array of which colors belong in sequence.

• key_indexes – An ascending array of indexes of the output to map the respective color from key_colors. First index must always be 0, last index must always be KeyColors - 1.

Returns

std::array<tcod::ColorRGB, OutSize>

Throws

std::invalid_argument – Issues with the key arrays will throw an error.

Friends

inline friend TCODLIB_API_INLINE_EXPORT friend TCODColor operator* (float value, const TCODColor &color) noexcept