Continuando nossa série de artigos traduzidos do site lazyfoo, iremos ver agora alterar as cores de texturas renderizadas, modulando essas texturas usando várias cores.
Modulação de cores permite que você altera a cor das texturas renderizada. Aqui iremos ver como modular uma textura usando várias cores.
//Texture wrapper class
class LTexture
{
public:
//Initializes variables
LTexture();
//Deallocates memory
~LTexture();
//Loads image at specified path
bool loadFromFile( std::string path );
//Deallocates texture
void free();
//Set color modulation
void setColor( Uint8 red, Uint8 green, Uint8 blue );
//Renders texture at given point
void render( int x, int y, SDL_Rect* clip = NULL );
//Gets image dimensions
int getWidth();
int getHeight();
private:
//The actual hardware texture
SDL_Texture* mTexture;
//Image dimensions
int mWidth;
int mHeight;
};
Adicionamos uma função na classe da textura que permitirá que a modulação da textura seja feita. Tudo que essa função fará é receber os componentes vermelho, verde e azul de uma cor.
void LTexture::setColor( Uint8 red, Uint8 green, Uint8 blue )
{
//Modulate texture
SDL_SetTextureColorMod( mTexture, red, green, blue );
}
Fazer a modulação da textura é tão simples quanto chamar a função SDL_SetTextureColorMod. Você apenas informa a textura que quer modular e a cor que deseja utilizar para modulá-la.
Agora, como a modulação de cores funcional? Digamos que você tenha essa textura:
E você modula ela com os componentes vermelho 255 verde 128 e azul 255. Você ficará com isso:
Você pode ter percebido que SDL_SetTextureColorMod aceita Uint8 como argumento para os componentes da core. Um Uint8 é apenas um inteiro sem sinal de 8 bits. Isso significa que pode receber apenas valores entre 0 e 255. 128 fica no meio do caminho entre 0 e 255, assim quando você modula o componente verde para 128 você diminui a intensidade do componente verde para todos os pixels da textura.
Os componentes vermelho e azul não são afetados pois eles não possuem nenhum componente verde neles, mas o componente verde fica com metade do brilho e o branco torna-se um magenta claro (magenta é vermelho 255 verde 0 azul 255). A modulação das cores é apenas uma maneira de multiplicar as cores por toda a textura.
//Main loop flag
bool quit = false;
//Event handler
SDL_Event e;
//Modulation components
Uint8 r = 255;
Uint8 g = 255;
Uint8 b = 255;
Aqui chegamos logo antes do loop principal. No nosso exemplo, iremos modular os componentes individuais das cores usando o pressionamento de algumas teclas. Para fazer isso, precisamos manter um registro dos valores dos componentes das cores.
//While application is running
while( !quit )
{
//Handle events on queue
while( SDL_PollEvent( &e ) != 0 )
{
//User requests quit
if( e.type == SDL_QUIT )
{
quit = true;
}
//On keypress change rgb values
else if( e.type == SDL_KEYDOWN )
{
switch( e.key.keysym.sym )
{
//Increase red
case SDLK_q:
r += 32;
break;
//Increase green
case SDLK_w:
g += 32;
break;
//Increase blue
case SDLK_e:
b += 32;
break;
//Decrease red
case SDLK_a:
r -= 32;
break;
//Decrease green
case SDLK_s:
g -= 32;
break;
//Decrease blue
case SDLK_d:
b -= 32;
break;
}
}
}
No nosso loop de eventos, usaremos as teclas q, w e e para aumentar os componentes vermelho, verde e azul e a, s e d para diminuir os componentes vermelho, verde e azul, respectivamente. Iremos aumentar, diminuir os componentes por 32, de forma que possamos perceber a mudança a cada vez que pressionamos uma tecla.
//Clear screen
SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
SDL_RenderClear( gRenderer );
//Modulate and render texture
gModulatedTexture.setColor( r, g, b );
gModulatedTexture.render( 0, 0 );
//Update screen
SDL_RenderPresent( gRenderer );
}
E aqui ajustamos a modulação da textura e renderizamos ela.
Baixe o código fonte e os arquivos de mídia desse artigo aqui.