Dye Class Reference

#include <dye.h>

Public Member Functions
	Dye (const std::string &dye)
	~Dye ()
const DyePalette *	getSPalete () const
const DyePalette *	getAPalete () const
int	getType () const
void	normalDye (uint32_t *pixels, const int bufSize) const
void	normalOGLDye (uint32_t *pixels, const int bufSize) const

Static Public Member Functions
static void	instantiate (std::string &target, const std::string &palettes)

Private Attributes
DyePalette *	mDyePalettes [dyePalateSize]

Detailed Description

Class for dispatching pixel-recoloring amongst several palettes.

Definition at line 40 of file dye.h.

Constructor & Destructor Documentation

Dye()

Dye::Dye ( const std::string &  dye )

explicit

Creates a set of palettes based on the given string.

The parts of string are separated by semi-colons. Each part starts by an uppercase letter, followed by a colon and then a palette name.

Definition at line 43 of file dye.cpp.

{
    for (int i = 0; i < dyePalateSize; ++i)
        mDyePalettes[i] = nullptr;
 
    if (description.empty())
        return;
 
    size_t next_pos = 0;
    const size_t length = description.length();
    do
    {
        const size_t pos = next_pos;
        next_pos = description.find(';', pos);
 
        if (next_pos == std::string::npos)
            next_pos = length;
 
        if (next_pos <= pos + 3 || description[pos + 1] != ':')
        {
            logger->log("Error, invalid dye: %s", description.c_str());
            return;
        }
 
        int i = 0;
 
        switch (description[pos])
        {
            case 'R': i = 0; break;
            case 'G': i = 1; break;
            case 'Y': i = 2; break;
            case 'B': i = 3; break;
            case 'M': i = 4; break;
            case 'C': i = 5; break;
            case 'W': i = 6; break;
            case 'S': i = 7; break;
            case 'A': i = 8; break;
            default:
                logger->log("Error, invalid dye: %s", description.c_str());
                return;
        }
        mDyePalettes[i] = new DyePalette(description.substr(
            pos + 2, next_pos - pos - 2), i != 8 ? 6 : 8);
        ++next_pos;
    }
    while (next_pos < length);
}

References dyePalateSize, Logger::log(), logger, and mDyePalettes.

~Dye()

Dye::~Dye

(

)

Destroys the associated palettes.

Definition at line 91 of file dye.cpp.

{
    for (int i = 0; i < dyePalateSize; ++i)
        delete2(mDyePalettes[i])
}

References delete2, dyePalateSize, and mDyePalettes.

Member Function Documentation

getAPalete()

const DyePalette* Dye::getAPalete ( ) const

inline

Return special dye palete (A)

Definition at line 73 of file dye.h.

        { return mDyePalettes[aPaleteIndex]; }

References aPaleteIndex, and mDyePalettes.

Referenced by ImageHelper::load(), OpenGLImageHelper::load(), SafeOpenGLImageHelper::load(), and SDLImageHelper::load().

getSPalete()

const DyePalette* Dye::getSPalete ( ) const

inline

Return special dye palete (S)

Definition at line 67 of file dye.h.

        { return mDyePalettes[sPaleteIndex]; }

References mDyePalettes, and sPaleteIndex.

Referenced by ImageHelper::load(), OpenGLImageHelper::load(), SafeOpenGLImageHelper::load(), and SDLImageHelper::load().

getType()

int Dye::getType

(

)

const

Return dye type for S - 1, for A - 2, 0 for other

Definition at line 149 of file dye.cpp.

{
    if (mDyePalettes[sPaleteIndex] != nullptr)
        return 1;
    if (mDyePalettes[aPaleteIndex] != nullptr)
        return 2;
    return 0;
}

References aPaleteIndex, mDyePalettes, and sPaleteIndex.

Referenced by ImageHelper::load(), OpenGLImageHelper::load(), SafeOpenGLImageHelper::load(), and SDLImageHelper::load().

instantiate()

void Dye::instantiate ( std::string &  target, const std::string &  palettes  )

static

Fills the blank in a dye placeholder with some palette names.

Definition at line 97 of file dye.cpp.

{
    size_t next_pos = target.find('|');
 
    if (next_pos == std::string::npos || palettes.empty())
        return;
 
    ++next_pos;
 
    std::ostringstream s;
    s << target.substr(0, next_pos);
    size_t last_pos = target.length();
    size_t pal_pos = 0;
    do
    {
        const size_t pos = next_pos;
        next_pos = target.find(';', pos);
 
        if (next_pos == std::string::npos)
            next_pos = last_pos;
 
        if (next_pos == pos + 1 && pal_pos != std::string::npos)
        {
            const size_t pal_next_pos = palettes.find(';', pal_pos);
            s << target[pos] << ':';
            if (pal_next_pos == std::string::npos)
            {
                s << palettes.substr(pal_pos);
                s << target.substr(next_pos);
                break;
            }
            s << palettes.substr(pal_pos, pal_next_pos - pal_pos);
            pal_pos = pal_next_pos + 1;
        }
        else if (next_pos > pos + 2)
        {
            s << target.substr(pos, next_pos - pos);
        }
        else
        {
            logger->log("Error, invalid dye placeholder: %s", target.c_str());
            return;
        }
        s << target[next_pos];
        ++next_pos;
    }
    while (next_pos < last_pos);
 
    target = s.str();
}

References Logger::log(), and logger.

Referenced by Particle::addEffect(), ParticleEngine::addEffect(), SimpleAnimation::initializeAnimation(), SpriteDef::loadImageSet(), and ParticleEmitter::ParticleEmitter().

normalDye()

void Dye::normalDye	(	uint32_t *	pixels,
		const int	bufSize
	)		const

Definition at line 158 of file dye.cpp.

{
    if (pixels == nullptr)
        return;
 
    for (const uint32_t *const p_end = pixels + CAST_SIZE(bufSize);
         pixels != p_end;
         ++ pixels)
    {
        const uint32_t p = *pixels;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        const int alpha = p & 0xff000000;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        const int alpha = p & 0xff;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        if (alpha == 0)
            continue;
        unsigned int color[3];
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        color[0] = (p) & 255U;
        color[1] = (p >> 8U) & 255U;
        color[2] = (p >> 16U) & 255U;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        color[0] = (p >> 24U) & 255U;
        color[1] = (p >> 16U) & 255U;
        color[2] = (p >> 8U) & 255U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        const unsigned int cmax = std::max(
            color[0], std::max(color[1], color[2]));
        if (cmax == 0)
            continue;
 
        const unsigned int cmin = std::min(
            color[0], std::min(color[1], color[2]));
        const unsigned int intensity = color[0] + color[1] + color[2];
 
        if (cmin != cmax && (cmin != 0 || (intensity != cmax
            && intensity != 2 * cmax)))
        {
            // not pure
            continue;
        }
 
        const unsigned int i = static_cast<int>(color[0] != 0) |
            (static_cast<int>(color[1] != 0) << 1) |
            (static_cast<int>(color[2] != 0) << 2);
 
        if (mDyePalettes[i - 1] != nullptr)
            mDyePalettes[i - 1]->getColor(cmax, color);
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        *pixels = (color[0]) | (color[1] << 8)
            | (color[2] << 16) | alpha;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        *pixels = (color[0] << 24) | (color[1] << 16)
            | (color[2] << 8) | alpha;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
    }
}

References CAST_SIZE.

Referenced by ImageHelper::load(), and SDLImageHelper::load().

normalOGLDye()

void Dye::normalOGLDye	(	uint32_t *	pixels,
		const int	bufSize
	)		const

Definition at line 224 of file dye.cpp.

{
    if (pixels == nullptr)
        return;
 
    for (const uint32_t *const p_end = pixels + CAST_SIZE(bufSize);
         pixels != p_end;
         ++ pixels)
    {
        const uint32_t p = *pixels;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        const uint32_t alpha = p & 255U;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        const uint32_t alpha = p & 0xff000000U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        if (alpha == 0)
            continue;
        unsigned int color[3];
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        color[0] = (p >> 24U) & 255U;
        color[1] = (p >> 16U) & 255U;
        color[2] = (p >> 8U) & 255U;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        color[0] = (p) & 255U;
        color[1] = (p >> 8U) & 255U;
        color[2] = (p >> 16U) & 255U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        const unsigned int cmax = std::max(
            color[0], std::max(color[1], color[2]));
        if (cmax == 0)
            continue;
 
        const unsigned int cmin = std::min(
            color[0], std::min(color[1], color[2]));
        const unsigned int intensity = color[0] + color[1] + color[2];
 
        if (cmin != cmax && (cmin != 0 || (intensity != cmax
            && intensity != 2 * cmax)))
        {
            // not pure
            continue;
        }
 
        const unsigned int i = static_cast<int>(color[0] != 0) |
            (static_cast<int>(color[1] != 0) << 1) |
            (static_cast<int>(color[2] != 0) << 2);
 
        if (mDyePalettes[i - 1] != nullptr)
            mDyePalettes[i - 1]->getColor(cmax, color);
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        *pixels = (color[0] << 24) | (color[1] << 16)
            | (color[2] << 8) | alpha;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
        *pixels = (color[0]) | (color[1] << 8)
            | (color[2] << 16) | alpha;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
    }
}

References CAST_SIZE.

Referenced by OpenGLImageHelper::load(), and SafeOpenGLImageHelper::load().

Field Documentation

mDyePalettes

DyePalette* Dye::mDyePalettes[dyePalateSize]

private

The order of the palettes, as well as their uppercase letter, is:

Red, Green, Yellow, Blue, Magenta, White (or rather gray), Simple.

Definition at line 93 of file dye.h.

Referenced by Dye(), getAPalete(), getSPalete(), getType(), and ~Dye().

---

The documentation for this class was generated from the following files:

• src/resources/dye/dye.h (986a3bf)
• src/resources/dye/dye.cpp (986a3bf)