quinta-feira, 21 de outubro de 2010

Paletas de cores implementadas em C++/Allegro

Olá, programadores de jogos em C/C++ e Allegro!

Neste artigo vou apresentar a vocês algumas implementações de paletas de cores, correspondentes às paletas de cores de clássicos consoles de videogame e computadores antigos. Especificamente, você vai encontrar aqui paletas de cores implementadas em C++ usando a biblioteca Allegro para compôr as cores, correspondentes às paletas dos consoles NES, Atari 2600, MSX, ZX Spectrum e além dessas, uma paleta personalizada que eu mesmo criei.

Obviamente, aqui eu suponho que você já tenha alguma experiência tanto em programação C/C++ como na biblioteca Allegro. Caso você não tenha nem noção de Allegro, confira antes o meu tutorial para iniciantes sobre essa maravilhosa biblioteca de jogos, clicando no link a seguir: Allegro - Uma biblioteca em C para programação de jogos.

Ah, outro detalhe: Aqui a implementação das paletas é "solta", ou seja, você vai precisar encapsular isso tudo numa classe qualquer (em C++) ou numa função qualquer (em C). Além disso, há formas automáticas de gerar essas paletas usando certos algoritmos. Mas como eu não conheço estes algoritmos e gosto de fazer isso "na mão", eis os códigos em C++ para criar manualmente as paletas.

Clique nas imagens das paletas para ver em tamanho original e fazer o download da imagem, se quizer ter uma referência de como as cores aparecem depois na tela.




Paleta de cores do Atari 2600





// Paleta de cores do Atari 2600 - 128 cores
// Implementacao em C++/Allegro

#define PALETTE_SIZE 128

#define C_BLACK 0 // Preto
#define C_GRAY 1 // Cinza (intensidade +0 a +6)
#define C_WHITE 7 // Branco
#define C_YELLOW 8 // Amarelo (intensidade +0 a +7)
#define C_BROWN 16 // Marrom (intensidade +0 a +7)
#define C_ORANGE 24 // Laranja (intensidade +0 a +7)
#define C_RED 32 // Vermelho (intensidade +0 a +7)
#define C_MAGENTA 40 // Magenta (intensidade +0 a +1)
#define C_PINK 42 // Rosa (intensidade +0 a +7)
#define C_VIOLET 48 // Violeta (intensidade +0 a +7)
#define C_DKBLUE 56 // Azul escuro (intensidade +0 a +7)
#define C_BLUE 64 // Azul (intensidade +0 a +7)
#define C_LTBLUE 72 // Azul claro (intensidade +0 a +7)
#define C_CYAN 80 // Ciano (intensidade +0 a +7)
#define C_TEAL 88 // Teal (intensidade +0 a +7)
#define C_GREEN 96 // Verde (intensidade +0 a +7)
#define C_GREENISH 104 // Esverdeado (intensidade +0 a +7)
#define C_OLIVE 112 // Oliva (intensidade +0 a +7)
#define C_OCHRE 120 // Ocre (intensidade +0 a +7)

int pal[PALETTE_SIZE];

pal[ 0] = makecol( 0, 0, 0);
pal[ 1] = makecol( 64, 64, 64);
pal[ 2] = makecol(108, 108, 108);
pal[ 3] = makecol(144, 144, 144);
pal[ 4] = makecol(176, 176, 176);
pal[ 5] = makecol(200, 200, 200);
pal[ 6] = makecol(220, 220, 220);
pal[ 7] = makecol(236, 236, 236);
pal[ 8] = makecol( 68, 68, 0);
pal[ 9] = makecol(100, 100, 16);
pal[ 10] = makecol(132, 132, 36);
pal[ 11] = makecol(160, 160, 52);
pal[ 12] = makecol(184, 184, 64);
pal[ 13] = makecol(208, 208, 80);
pal[ 14] = makecol(232, 232, 92);
pal[ 15] = makecol(252, 252, 104);
pal[ 16] = makecol(112, 40, 0);
pal[ 17] = makecol(132, 68, 20);
pal[ 18] = makecol(152, 92, 40);
pal[ 19] = makecol(172, 120, 60);
pal[ 20] = makecol(188, 140, 76);
pal[ 21] = makecol(204, 160, 92);
pal[ 22] = makecol(220, 180, 104);
pal[ 23] = makecol(236, 200, 120);
pal[ 24] = makecol(132, 24, 0);
pal[ 25] = makecol(152, 52, 24);
pal[ 26] = makecol(172, 80, 48);
pal[ 27] = makecol(192, 104, 72);
pal[ 28] = makecol(208, 128, 92);
pal[ 29] = makecol(224, 148, 112);
pal[ 30] = makecol(236, 168, 128);
pal[ 31] = makecol(252, 188, 148);
pal[ 32] = makecol(136, 0, 0);
pal[ 33] = makecol(156, 32, 32);
pal[ 34] = makecol(176, 60, 60);
pal[ 35] = makecol(192, 88, 88);
pal[ 36] = makecol(208, 112, 112);
pal[ 37] = makecol(224, 136, 136);
pal[ 38] = makecol(236, 160, 160);
pal[ 39] = makecol(252, 180, 180);
pal[ 40] = makecol(120, 0, 92);
pal[ 41] = makecol(140, 32, 116);
pal[ 42] = makecol(160, 60, 136);
pal[ 43] = makecol(176, 88, 156);
pal[ 44] = makecol(192, 112, 176);
pal[ 45] = makecol(208, 132, 192);
pal[ 46] = makecol(220, 156, 208);
pal[ 47] = makecol(236, 176, 224);
pal[ 48] = makecol( 72, 0, 120);
pal[ 49] = makecol( 96, 32, 144);
pal[ 50] = makecol(120, 60, 164);
pal[ 51] = makecol(140, 88, 184);
pal[ 52] = makecol(160, 112, 204);
pal[ 53] = makecol(180, 132, 220);
pal[ 54] = makecol(196, 156, 236);
pal[ 55] = makecol(212, 176, 252);
pal[ 56] = makecol( 20, 0, 132);
pal[ 57] = makecol( 48, 32, 152);
pal[ 58] = makecol( 76, 60, 172);
pal[ 59] = makecol(104, 88, 192);
pal[ 60] = makecol(124, 112, 208);
pal[ 61] = makecol(148, 136, 224);
pal[ 62] = makecol(168, 160, 236);
pal[ 63] = makecol(188, 180, 252);
pal[ 64] = makecol( 0, 0, 136);
pal[ 65] = makecol( 28, 32, 156);
pal[ 66] = makecol( 56, 64, 176);
pal[ 67] = makecol( 80, 92, 192);
pal[ 68] = makecol(104, 116, 208);
pal[ 69] = makecol(124, 140, 224);
pal[ 70] = makecol(144, 164, 236);
pal[ 71] = makecol(164, 184, 252);
pal[ 72] = makecol( 0, 24, 124);
pal[ 73] = makecol( 28, 56, 144);
pal[ 74] = makecol( 56, 84, 168);
pal[ 75] = makecol( 80, 112, 188);
pal[ 76] = makecol(104, 136, 204);
pal[ 77] = makecol(124, 156, 220);
pal[ 78] = makecol(144, 180, 236);
pal[ 79] = makecol(164, 200, 252);
pal[ 80] = makecol( 0, 44, 92);
pal[ 81] = makecol( 28, 76, 120);
pal[ 82] = makecol( 56, 104, 144);
pal[ 83] = makecol( 80, 132, 172);
pal[ 84] = makecol(104, 156, 192);
pal[ 85] = makecol(124, 180, 212);
pal[ 86] = makecol(144, 204, 232);
pal[ 87] = makecol(164, 224, 252);
pal[ 88] = makecol( 0, 60, 44);
pal[ 89] = makecol( 28, 92, 72);
pal[ 90] = makecol( 56, 124, 100);
pal[ 91] = makecol( 80, 156, 128);
pal[ 92] = makecol(104, 180, 148);
pal[ 93] = makecol(124, 208, 172);
pal[ 94] = makecol(144, 228, 192);
pal[ 95] = makecol(164, 252, 212);
pal[ 96] = makecol( 0, 60, 0);
pal[ 97] = makecol( 32, 92, 32);
pal[ 98] = makecol( 64, 124, 64);
pal[ 99] = makecol( 92, 156, 92);
pal[100] = makecol(116, 180, 116);
pal[101] = makecol(140, 208, 140);
pal[102] = makecol(164, 228, 164);
pal[103] = makecol(184, 252, 184);
pal[104] = makecol( 20, 56, 0);
pal[105] = makecol( 52, 92, 28);
pal[106] = makecol( 80, 124, 56);
pal[107] = makecol(108, 152, 80);
pal[108] = makecol(132, 180, 104);
pal[109] = makecol(156, 204, 124);
pal[110] = makecol(180, 228, 144);
pal[111] = makecol(200, 252, 164);
pal[112] = makecol( 44, 48, 0);
pal[113] = makecol( 76, 80, 28);
pal[114] = makecol(104, 112, 52);
pal[115] = makecol(132, 140, 76);
pal[116] = makecol(156, 168, 100);
pal[117] = makecol(180, 192, 120);
pal[118] = makecol(204, 212, 136);
pal[119] = makecol(224, 236, 156);
pal[120] = makecol( 68, 40, 0);
pal[121] = makecol(100, 72, 24);
pal[122] = makecol(132, 104, 48);
pal[123] = makecol(160, 132, 68);
pal[124] = makecol(184, 156, 88);
pal[125] = makecol(208, 180, 108);
pal[126] = makecol(232, 204, 124);
pal[127] = makecol(252, 224, 140);



Paleta de cores do Nintendo 8-bit (NES)





// Paleta de cores do NES - 64 cores
// Implementacao C++/Allegro

#define PALETTE_SIZE 64

int pal[PALETTE_SIZE];

pal[ 0] = makecol(0x80, 0x80, 0x80);
pal[ 1] = makecol(0x00, 0x3d, 0xa6);
pal[ 2] = makecol(0x00, 0x12, 0xb0);
pal[ 3] = makecol(0x44, 0x00, 0x96);
pal[ 4] = makecol(0xa1, 0x00, 0x5e);
pal[ 5] = makecol(0xc7, 0x00, 0x28);
pal[ 6] = makecol(0xba, 0x06, 0x00);
pal[ 7] = makecol(0x8c, 0x17, 0x00);
pal[ 8] = makecol(0x5c, 0x2f, 0x00);
pal[ 9] = makecol(0x10, 0x45, 0x00);
pal[10] = makecol(0x05, 0x4a, 0x00);
pal[11] = makecol(0x00, 0x47, 0x2e);
pal[12] = makecol(0x00, 0x41, 0x66);
pal[13] = makecol(0x00, 0x00, 0x00);
pal[14] = makecol(0x05, 0x05, 0x05);
pal[15] = makecol(0x05, 0x05, 0x05);
pal[16] = makecol(0xc7, 0xc7, 0xc7);
pal[17] = makecol(0x00, 0x77, 0xff);
pal[18] = makecol(0x21, 0x55, 0xff);
pal[19] = makecol(0x82, 0x37, 0xfa);
pal[20] = makecol(0xeb, 0x2f, 0xb5);
pal[21] = makecol(0xff, 0x29, 0x50);
pal[22] = makecol(0xff, 0x22, 0x00);
pal[23] = makecol(0xd6, 0x32, 0x00);
pal[24] = makecol(0xc4, 0x62, 0x00);
pal[25] = makecol(0x35, 0x80, 0x00);
pal[26] = makecol(0x05, 0x8f, 0x00);
pal[27] = makecol(0x00, 0x8a, 0x55);
pal[28] = makecol(0x00, 0x99, 0xcc);
pal[29] = makecol(0x21, 0x21, 0x21);
pal[30] = makecol(0x09, 0x09, 0x09);
pal[31] = makecol(0x09, 0x09, 0x09);
pal[32] = makecol(0xff, 0xff, 0xff);
pal[33] = makecol(0x0f, 0xd7, 0xff);
pal[34] = makecol(0x69, 0xa2, 0xff);
pal[35] = makecol(0xd4, 0x80, 0xff);
pal[36] = makecol(0xff, 0x45, 0xf3);
pal[37] = makecol(0xff, 0x61, 0x8b);
pal[38] = makecol(0xff, 0x88, 0x33);
pal[39] = makecol(0xff, 0x9c, 0x12);
pal[40] = makecol(0xfa, 0xbc, 0x20);
pal[41] = makecol(0x9f, 0xe3, 0x0e);
pal[42] = makecol(0x2b, 0xf0, 0x35);
pal[43] = makecol(0x0c, 0xf0, 0xa4);
pal[44] = makecol(0x05, 0xfb, 0xff);
pal[45] = makecol(0x5e, 0x5e, 0x5e);
pal[46] = makecol(0x0d, 0x0d, 0x0d);
pal[47] = makecol(0x0d, 0x0d, 0x0d);
pal[48] = makecol(0xff, 0xff, 0xff);
pal[49] = makecol(0xa6, 0xfc, 0xff);
pal[50] = makecol(0xb3, 0xec, 0xff);
pal[51] = makecol(0xda, 0xab, 0xeb);
pal[52] = makecol(0xff, 0xa8, 0xf9);
pal[53] = makecol(0xff, 0xab, 0xb3);
pal[54] = makecol(0xff, 0xd2, 0xb0);
pal[55] = makecol(0xff, 0xef, 0xa6);
pal[56] = makecol(0xff, 0xf7, 0x9c);
pal[57] = makecol(0xd7, 0xe8, 0x95);
pal[58] = makecol(0xa6, 0xed, 0xaf);
pal[59] = makecol(0xa2, 0xf2, 0xda);
pal[60] = makecol(0x99, 0xff, 0xfc);
pal[61] = makecol(0xdd, 0xdd, 0xdd);
pal[62] = makecol(0x11, 0x11, 0x11);
pal[63] = makecol(0x11, 0x11, 0x11);



Paleta de cores do ZX Spectrum





// Paleta de cores do ZX Spectrum - 16 cores
// Implementacao C++/Allegro

#define PALETTE_SIZE 16

#define C_BLACK 0
#define C_BLUE 1
#define C_RED 2
#define C_MAGENTA 3
#define C_GREEN 4
#define C_CYAN 5
#define C_YELLOW 6
#define C_GRAY 7
#define C_BLACK2 8
#define C_BTBLUE 9
#define C_BTRED 10
#define C_BTMAGENTA 11
#define C_BTGREEN 12
#define C_BTCYAN 13
#define C_BTYELLOW 14
#define C_WHITE 15

int pal[PALETTE_SIZE];

pal[ 0] = makecol( 0, 0, 0 );
pal[ 1] = makecol( 0, 0, 205 );
pal[ 2] = makecol( 205, 0, 0 );
pal[ 3] = makecol( 205, 0, 205 );
pal[ 4] = makecol( 0, 205, 0 );
pal[ 5] = makecol( 0, 205, 205 );
pal[ 6] = makecol( 205, 205, 0 );
pal[ 7] = makecol( 212, 212, 212 );
pal[ 8] = makecol( 0, 0, 0 );
pal[ 9] = makecol( 0, 0, 255 );
pal[10] = makecol( 255, 0, 0 );
pal[11] = makecol( 255, 0, 255 );
pal[12] = makecol( 0, 255, 0 );
pal[13] = makecol( 0, 255, 255 );
pal[14] = makecol( 255, 255, 0 );
pal[15] = makecol( 255, 255, 255 );



Paleta de cores do MSX





// Paleta de cores do MSX - 16 cores
// Implementacao C++/Allegro

#define PALETTE_SIZE 16

#define C_TRANS 0
#define C_BLACK 1
#define C_GREEN 2
#define C_LTGREEN 3
#define C_BLUE 4
#define C_LTBLUE 5
#define C_DKRED 6
#define C_CYAN 7
#define C_RED 8
#define C_LTRED 9
#define C_YELLOW 10
#define C_LTYELLOW 11
#define C_DKGREEN 12
#define C_MAGENTA 13
#define C_GRAY 14
#define C_WHITE 15

int pal[PALETTE_SIZE];

pal[ 0] = makecol( 4, 6, 4 );
pal[ 1] = makecol( 4, 6, 4 );
pal[ 2] = makecol( 36, 202, 68 );
pal[ 3] = makecol( 92, 218, 124 );
pal[ 4] = makecol( 84, 82, 236 );
pal[ 5] = makecol( 124, 114, 244 );
pal[ 6] = makecol( 212, 82, 76 );
pal[ 7] = makecol( 68, 234, 244 );
pal[ 8] = makecol( 244, 82, 84 );
pal[ 9] = makecol( 244, 122, 124 );
pal[10] = makecol( 212, 194, 84 );
pal[11] = makecol( 228, 202, 132 );
pal[12] = makecol( 36, 178, 60 );
pal[13] = makecol( 204, 90, 188 );
pal[14] = makecol( 204, 202, 204 );
pal[15] = makecol( 244, 246, 244 );



Minha paleta de cores personalizada




// Paleta de cores personalizada - 32 cores
// Implementacao em C++/Allegro

#define PALETTE_SIZE 32

#define C_BLACK 0
#define C_RED 1
#define C_GREEN 5
#define C_BLUE 9
#define C_YELLOW 13
#define C_CYAN 17
#define C_MAGENTA 21
#define C_ORANGE 25
#define C_BROWN 27
#define C_GRAY 29
#define C_WHITE 31

int pal[PALETTE_SIZE];

pal[0 ] = makecol( 8, 8, 8 ); // BLACK
pal[1 ] = makecol( 224, 160, 160 ); // RED
pal[2 ] = makecol( 224, 96, 96 );
pal[3 ] = makecol( 224, 32, 32 );
pal[4 ] = makecol( 160, 32, 32 );
pal[5 ] = makecol( 160, 224, 160 ); // GREEN
pal[6 ] = makecol( 96, 224, 96 );
pal[7 ] = makecol( 32, 224, 32 );
pal[8 ] = makecol( 32, 160, 32 );
pal[9 ] = makecol( 160, 160, 224 ); // BLUE
pal[10] = makecol( 96, 96, 224 );
pal[11] = makecol( 32, 32, 224 );
pal[12] = makecol( 32, 32, 160 );
pal[13] = makecol( 224, 224, 160 ); // YELLOW
pal[14] = makecol( 224, 224, 96 );
pal[15] = makecol( 160, 160, 32 );
pal[16] = makecol( 96, 96, 16 );
pal[17] = makecol( 160, 224, 224 ); // CYAN
pal[18] = makecol( 96, 224, 224 );
pal[19] = makecol( 32, 160, 160 );
pal[20] = makecol( 16, 96, 96 );
pal[21] = makecol( 224, 160, 224 ); // MAGENTA
pal[22] = makecol( 224, 96, 224 );
pal[23] = makecol( 224, 32, 224 );
pal[24] = makecol( 160, 32, 160 );
pal[25] = makecol( 224, 160, 32 ); // ORANGE
pal[26] = makecol( 224, 96, 16 );
pal[27] = makecol( 160, 96, 32 ); // BROWN
pal[28] = makecol( 96, 32, 16 );
pal[29] = makecol( 96, 96, 96 ); // GRAY
pal[30] = makecol( 160, 160, 160 );
pal[31] = makecol( 255, 255, 255 ); // WHITE




Quanta cor, né? Kkkkkkkkkk...
Caso crie uma paleta de cores diferente, me envie!