Graficacin.

FUNCIONES OPENGL PARA MATRICES DE PXELES (PATRONES).

Hay dos funciones de OpenGL que podemos utilizar para definir una forma o patron especificados, mediante una
matriz rectangular. Una sirve para mapa de pxeles y la otra para mapa de bits.
Funcin de mapa de bits de OpenGL.
Lo primero que tenemos que entender es la manera de definir una matriz para mapas de bits
Tomemos como ejemplo el dibujo de la letra X en una matriz de mapa de bits de 16 x 16 bits, donde por medio de
ceros y unos dibujaremos la letra.
Los mapas de bits son almancenados en grupos de 8 bits,
lo que da.
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1000 0000 0000 0001 Lnea 1
0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0100 0000 0000 0010 Lnea 2
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0
0010 0000 0000 0100 Lnea 3
0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0
0001 0000 0000 1000 Lnea 4
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0
0000 1000 0001 0000 Lnea 5
0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0
1000 0000 0000 0001 Lnea 16
0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0
La matriz actual es de 16 por 16 y siempre debe comenzar
0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0
el diseo de la ltima lnea hacia arriba.
0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0
La lnea 16 se compone de dos grupos 8 bits, el primero
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0
1000 0000 y el segundo es 0000 0001, ahora, simplemente
0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0
traducir cada uno de los grupos de binario a hexadecimal
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

Analicemos la lnea 16
1000 0000 0000 0001 son dos grupos de ocho bits el primero es 1000 0000 y el segundo es 0000 0001, para
representar esto es hexadecimal consideramos el primer grupo 1000 0000 binario, que equivale en hexadecimal al
numero 80, para representarlo usamos 0x80, ahora para el segundo grupo de ocho bits de la misma lnea 16 que es
0000 0001 su equivalente convertido de binario a hexadeximal es 01, esto es 0x01, y as sucesivamente.
Cambio a cdigo.
unsigned char bitmapX[ ] = { 0x80, 0x01,
0x40, 0x02,
0x20, 0x04,
0x10, 0x08,
0x08, 0x10,
0x04, 0x20,
0x02, 0x40,
0x01, 0x80,
0x01, 0x80,
0x02, 0x40,
0x04, 0x20,
0x08, 0x10,
0x10, 0x08,
0x20, 0x04,
0x40, 0x02,
0x80, 0x01,

Javier Snchez Padilla.

// 0x80=1000 0000 y 0x01=0000 0001 de la lnea 16

// 0x40=0100 0000 y 0x02=0000 0010 de la lnea 15
// 0x20=0010 0000 y 0x04=0000 0100 de la lnea 14
// 0x10=0001 0000 y 0x08=0000 1000 de la linea 13
// 0x08=0000 1000 y 0x10=0001 0000 de la lnea 12
// 0x04=0000 0100 y 0x20=0010 0000 de la lnea 11
// 0x02=0000 0010 y 0x40=0100 0000 de la lnea 10
// 0x01=0000 0001 y 0x80=1000 0000 de la lnea 09
// 0x01=0000 0001 y 0x80=1000 0000 de la lnea 08
// 0x02=0000 0010 y 0x40=0100 0000 de la lnea 07
// 0x04=0000 0100 y 0x20=0010 0000 de la lnea 06
// 0x08=0000 1000 y 0x10=0001 0000 de la lnea 05
// 0x10=0001 0000 y 0x08=0000 1000 de la linea 04
// 0x20=0010 0000 y 0x04=0000 0100 de la lnea 03
// 0x40=0100 0000 y 0x02=0000 0010 de la lnea 02
// 0x80=1000 0000 y 0x01=0000 0001 de la lnea 01 } ;

Pg. 26 de 99

Graficacin.

Como representar el mapa de bits en la pantalla, usando la instruccin glRaster(x,y);

Incremento en X
Incremento en Y

ANCHO
Posicin actual del

raster

EL MAPA DE BITS

ALTO

(xOrigen,
Yorigen)
Programa para el diseo de una carita feliz
#include <cstdlib>
#include <iostream>
#include <gl\glut.h>
using namespace std;
unsigned char bitmapX[
{ 0x1f, 0xf8, //
0x3e, 0x7c, //
0x3c, 0x3c, //
0x20, 0x04, //
0x60, 0x06, //
0x4f, 0xf2, //
0x5f, 0xfa, //
0xfc, 0x3f, //
0x7e, 0x7f, //
0xff, 0xff, //
0x39, 0xce, //
0x61, 0x86, //
0x21, 0x84, //
0x21, 0x84, //
0x33, 0xcc, //
0x1f, 0xf8
//
} ;

] =
linea
linea
linea
lnea
lnea
lnea
linea
lnea
lnea
lnea
lnea
lnea
lnea
lnea
lnea
linea

16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1

void Inicializa(void)
{ glClearColor (0.1, 0.3, 0.4, 0.0);
glMatrixMode (GL_PROJECTION);
gluOrtho2D (0.0, 40.0, 0.0, 40.0);
}

// Color de la ventana
// Parametros de proyeccion

void MatrizBitMap(void)
{ glClear (GL_COLOR_BUFFER_BIT);
glColor3f(1.0,1.0,1.0); glRasterPos2i(0,0); glBitmap(16,16,0.0,0.0,0.0,0.0,bitmapX);
glColor3f(0.0,1.0,1.0); glRasterPos2i(10,10); glBitmap(16,16,0.0,0.0,0.0,0.0,bitmapX);
glColor3f(0.0,0.0,1.0); glRasterPos2i(20,30); glBitmap(16,16,0.0,0.0,0.0,0.0,bitmapX);
glFlush(); }
int main(int argc, char *argv[])
{ glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB );
glutInitWindowPosition (50, 100);
glutInitWindowSize (800,600);
glutCreateWindow ("Un Ejemplo de un programa en OpenGL");
Inicializa();
glutDisplayFunc(MatrizBitMap);
glutMainLoop();
system("PAUSE");
return EXIT_SUCCESS; }

Javier Snchez Padilla.

Pg. 27 de 99

Graficacin.

glBitmap ( witdh, height, x0, y0, xOffset, yOffset, bitShape ) ;

witdh, height proporcionan el numero de filas y columnas de la matriz bitShape, a cada elemento de bitShape se le
asigna un cero o un uno, un valor de uno indica que hay que mostrar el pixel correspondiente de acuerso a un valor
establecido, en caso de cero la matiz no se ve afectada. Los parametros xo, y0 indican la posicion inicial u origen
para la matriz. Los valores para xOffset y yOffset, se utilizan para desplazamiento de coordenadas para actualizar la
posicion actual de visualizacin del buffer de image despues de mostrar el mapa de bits.
glRasterPos* ( ) ;
Establece la posicion actual de visualizacin (* es como glVertex) el valor por defecto es (0, 0, 0). El color sera el
definido y activo al momento de definir la matriz, una ez definida cualquier cambio posterior no afectara el mapa de
bits.
Usar un patron en una cuadricula de 10 filas por 9 columnas
000010000000____
000111000000____
001111100000____
011111110000____
111111111000____
000111000000____
000111000000____
000111000000____
000111000000____
000111000000____

10 filas

0*08
0*1C
0*3E
0*7F
0*FF
0*1C
0*1C
0*1C
0*1C
0*1C

0*00
0*00
0*00
0*00
0*80
0*00
0*00
0*00
0*00
0*00

12 columnas
16 columnas
En este caso como la matriz es 12 columnas, se todas formas tomaremos en grupos de ocho analicemos la lnea 5 que
es la parte mayor de la flecha
111111111000, separamos la primer parte en un grupo de ocho 1111 1111 convertido de binario a hexadecimal es
FF, quedando 0xFF, la segunda parte solamente puede formar un grupo de cuatro nmeros que es 1000 por lo tanto
aumentamos ceros para poder formar el grupo de ocho bits, quedando 1000 0000, el cual si conertimos este numero
de binario a hexadecimal nos queda 80, siendo 0x80.
111111111000 nos queda para convertir 1111111110000000, y separado para conversin a hexadecimal
11111111 FF 10000000 80
GLubyte bitShape [20] = { 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x1c, 0x00,
0xff, 0x80, 0x7f, 0x00, 0x3e, 0x00, 0x1c, 0x00, 0x08, 0x00 }
EJEMPLO PARA EL MANEJO DE PATRONES. A continuacin se muestra un ejemplo para el manejo de
patrones, tomaremos un packman basico con cuatro secuencias en una matriz de 8x4 en vertical y horizontal, esto es
8 bits por cada grupo de datos repetido cuatro veces

Cara uno del packman

Cara dos
Cara tres
Cara cuatro
Cada una de las caras esta en las matrices PackMan1 para cara uno, PackMan2 para cara dos y asi sucesivamente.
Este es el calculo para la cara uno, esta funcion me la revente en Excel, la funcion a usar es

=BIN.A.HEX(Celda_con_el_numero_binario)

Javier Snchez Padilla.

Pg. 28 de 99

Graficacin.

Ahora recordar que para meter las matrices en el codigo, debemos empezar de la ultima linea a la primera

unsigned char PackMan1[ ] = {

0x00, 0xff, 0xfe, 0x00,
0x0f, 0xff, 0xf8, 0x00,
0x3f, 0xff, 0xf0, 0x00,
0x7f, 0xff, 0xc0, 0x00,
0xff, 0xff, 0x80, 0x00,

0x00,
0x03,
0x1f,
0x7f,
0xff,
0xff,

0x0f,
0xff,
0xff,
0xff,
0xff,
0xff,

0xf0,
0xfc,
0xf8,
0xf0,
0xc0,
0x00,

0x00,
0x00,
0x00,
0x00,
0x00,
0x00,

0x00,
0x07,
0x3f,
0x7f,
0xff,
0xff,

0x7f,
0xff,
0xff,
0xff,
0xff,
0xff,

0xfe,
0xfc,
0xf0,
0xe0,
0x80,
0x00,

0x00,
0x00,
0x00,
0x00,
0x00,
0x00,

DESARROLLO DEL PROGRAMA.

#include <cstdlib>
#include <iostream>
#include <gl\glut.h>
using namespace std;
unsigned char PackMan1[ ] = {
0x00, 0xff, 0xfe, 0x00,
0x0f, 0xff, 0xf8, 0x00,
0x3f, 0xff, 0xf0, 0x00,
0x7f, 0xff, 0xc0, 0x00,
0xff, 0xff, 0x80, 0x00,
0xff, 0xff, 0x00, 0x00,
0x7f, 0xf1, 0xe0, 0x00,
0x3f, 0xe0, 0xfc, 0x00,
0x0f, 0xff, 0xff, 0x00,
0x01, 0xff, 0xff, 0x80,

0x00,
0x03,
0x1f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x3f,
0x07,
0x00,

0x0f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xf1,
0xff,
0x7f,

0xf0,
0xfc,
0xf8,
0xf0,
0xc0,
0x00,
0xc0,
0xf0,
0xfc,
0xff,
0xfe,

0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x00,

0x00,
0x07,
0x3f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x1f,
0x03,
0x00,

0x7f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xff,
0xff,
0x0f,

0xfe,
0xfc,
0xf0,
0xe0,
0x80,
0x00,
0xe0,
0xf8,
0xfe,
0xff,
0xe0,

0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x00 };

unsigned char PackMan2[ ] = {

0x00, 0xff, 0xff, 0x00,
0x0f, 0xff, 0xff, 0xf0,
0x3f, 0xff, 0xff, 0x80,
0x7f, 0xff, 0xfc, 0x00,
0xff, 0xff, 0xc0, 0x00,
0xff, 0xff, 0xe0, 0x00,
0x7f, 0xf1, 0xff, 0x00,
0x3f, 0xe0, 0xff, 0xfc,
0x0f, 0xff, 0xff, 0xf0,
0x01, 0xff, 0xff, 0x80,

0x00,
0x03,
0x1f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x3f,
0x07,
0x00,

0x0f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xf1,
0xff,
0x7f,

0xf0,
0xff,
0xff,
0xff,
0xf0,
0x80,
0xf0,
0xff,
0xff,
0xff,
0xfe,

0x00,
0xc0,
0xe0,
0x00,
0x00,
0x00,
0x00,
0xc0,
0xf8,
0xe0,
0x00,

0x00,
0x07,
0x3f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x1f,
0x03,
0x00,

0x7f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xff,
0xff,
0x0f,

0xfe,
0xff,
0xff,
0xfe,
0xe0,
0x80,
0xfc,
0xff,
0xff,
0xff,
0xe0,

0x00,
0xe0,
0xc0,
0x00,
0x00,
0x00,
0x00,
0xf0,
0xf8,
0xc0,
0x00 };

Javier Snchez Padilla.

Pg. 29 de 99

Graficacin.
unsigned char PackMan3[ ] = {
0x00, 0xff, 0xff, 0x80,
0x0f, 0xff, 0xff, 0xf0,
0x3f, 0xff, 0xff, 0xfc,
0x7f, 0xff, 0xff, 0xf8,
0xff, 0xff, 0xf0, 0x00,
0xff, 0xff, 0xf8, 0x00,
0x7f, 0xf1, 0xff, 0xfe,
0x3f, 0xe0, 0xff, 0xfc,
0x0f, 0xff, 0xff, 0xf0,
0x01, 0xff, 0xff, 0x80,

0x00,
0x03,
0x1f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x3f,
0x07,
0x00,

0x0f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xf1,
0xff,
0x7f,

0xf0,
0xff,
0xff,
0xff,
0xff,
0xc0,
0xff,
0xff,
0xff,
0xff,
0xfe,

0x00,
0xc0,
0xf8,
0xfc,
0xc0,
0x00,
0xc0,
0xfe,
0xfc,
0xe0,
0x00,

0x00,
0x07,
0x3f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x1f,
0x03,
0x00,

0x7f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xff,
0xff,
0x0f,

0xfe,
0xff,
0xff,
0xff,
0xfe,
0xc0,
0xff,
0xff,
0xff,
0xff,
0xe0,

0x00,
0xe0,
0xfc,
0xfe,
0x00,
0x00,
0xf8,
0xfe,
0xf8,
0xc0,
0x00 };

unsigned char PackMan4[ ] = {

0x00, 0xff, 0xff, 0x80,
0x0f, 0xff, 0xff, 0xf0,
0x3f, 0xff, 0xff, 0xfc,
0x7f, 0xff, 0xff, 0xfe,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0x7f, 0xf1, 0xff, 0xfe,
0x3f, 0xe0, 0xff, 0xfc,
0x0f, 0xff, 0xff, 0xf0,
0x01, 0xff, 0xff, 0x80,

0x00,
0x03,
0x1f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x3f,
0x07,
0x00,

0x0f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xf1,
0xff,
0x7f,

0xf0,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xfe,

0x00,
0xc0,
0xf8,
0xfe,
0xff,
0xff,
0xff,
0xfe,
0xfc,
0xe0,
0x00,

0x00,
0x07,
0x3f,
0x7f,
0xff,
0xff,
0xff,
0x7f,
0x1f,
0x03,
0x00,

0x7f,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,
0xff,
0xff,
0x0f,

0xfe,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xff,
0xe0,

0x00,
0xe0,
0xfc,
0xfe,
0xff,
0xff,
0xff,
0xfe,
0xf8,
0xc0,
0x00 };

int QueCara=1, PosX=2, PosY=30, incx=0, incy=0;

void Inicializa(void)
{ glClearColor (0.1, 0.3, 0.4, 0.0);
glMatrixMode (GL_PROJECTION);
gluOrtho2D (0.0, 500.0, 0.0, 500.0);
}
void teclas_especiales( int
{ switch ( key ) {
case GLUT_KEY_UP:
case GLUT_KEY_DOWN:
case GLUT_KEY_LEFT:
case GLUT_KEY_RIGHT:
case GLUT_KEY_F1:
}
}

// Color de la ventana
// Parametros de proyeccion

key, int PosX, int PosY )

incx=0;
incx=0;
incx=-1;
incx=1;
incx=0;

incy=1;
incy=-1;
incy=0;
incy=0;
incy=0;

break;
break;
break;
break;
break;

// detiene totalmente

void MatrizBitMap(void)
{ glClear (GL_COLOR_BUFFER_BIT);
glColor3f(1.0,1.0,1.0); glRasterPos2i(2,2); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan1);
glColor3f(0.0,1.0,1.0); glRasterPos2i(200,2); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan2);
glColor3f(0.0,0.0,1.0); glRasterPos2i(300,2); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan3);
glColor3f(0.0,0.0,1.0); glRasterPos2i(400,2); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan4);
glColor3f(1.0,1.,1.0);
if (QueCara==1) { glRasterPos2i(PosX,PosY); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan1); };
if (QueCara==2) { glRasterPos2i(PosX,PosY); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan2); };
if (QueCara==3) { glRasterPos2i(PosX,PosY); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan3); };
if (QueCara==4) { glRasterPos2i(PosX,PosY); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan4); };
QueCara++;
if (QueCara==5) QueCara=1;
PosX+=incx; PosY+=incy;
if (PosX>=500) PosX=2;
if (PosX<=0)
PosX=500;
if (PosY>=500) PosY=2;
if (PosY<=0)
PosY=500;
glutPostRedisplay();
glutSwapBuffers();
}
int main(int argc, char *argv[])
{ glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB );
glutInitWindowPosition (50, 100);
glutInitWindowSize (400,300);
glutCreateWindow ("Un Ejemplo de un programa en OpenGL");
Inicializa();
glutDisplayFunc(MatrizBitMap);
glutSpecialFunc(teclas_especiales);
glutMainLoop();
system("PAUSE");
return EXIT_SUCCESS; }
Javier Snchez Padilla.

Pg. 30 de 99