Hola.
Si eres un principiante en esto, es mejor que te explique antes como se suele trabajar tanto en pantalla, como con las imagenes.
Como sabes, cada unidad coloreada de la imagen, recibe el nombre de "pixel" y este se suele representar tanto en pantalla (al dibujar) como en el mapa de bits (bitmap) de la imagen cargada, como un indice de color a una paleta de colores o como una representacion de los componentes de color (YUV, RGB) de forma directa.
Las imagenes, dependiendo del formato que utilicen, pueden estar comprimidas o no. Como es evidente, en caso de estar comprimidas , la manipulacion es un tanto mas engorrosa, asi que lo mejor es que tires de alguna libreria que soporte la carga de dicho formato.
Otros formatos, como .bmp de Windows, son bastante sencillos de utilizar y aunque puede utilizar compresion en la imagen, casi nunca se utiliza.
Pero volviendo a la informacion de los pixeles, antes he comentado que se puede guardar la informacion de color como un indice a una paleta. En este caso, la imagen guarda en algun lugar una tabla con la informacion de color real de cada pixel.
Este indice se suele representar con 1, 4 u 8 bits, por lo que en el caso de indice de 1 bit, cada byte del mapa de imagen representarian 8 indices con valor 0 o 1 para 8 pixeles de imagen (con lo cual esto es util para representar imagenes que solo utilizan dos colores, pues ahorramos mucho mas espacio que si describieramos directamente el color.
El caso de 4 bits de indice, se suele utilizar cuando se trabaja con 16 colores (en 4 bits se pueden almacenar valores de 0 a 15) y un byte representaria dos pixeles de imagen.
Ahora bien, cuando un byte contiene informacion de varios pixeles, tenemos que conocer la correspondencia entre esos bits y la representacion en pantalla, ya que por ejemplo, si la imagen utiliza 16 colores, se podrian utilizar los 4 bits mas bajos del byte para representar el primer pixel o usar los 4 bits mas altos del byte para representar el primer pixel y los 4 mas bajos para representar el segundo.
Aclarado esto, decir que el caso de 8 bits de indice (1 byte), se utiliza cuando trabajamos con 256 colores,como es evidente.
La tabla de la paleta, representa la informacion de color "real". Generalmente, se suelen utilizar 32 bits (4 bytes) para codificar el color, pero tambien es posible que utilice otro tamaño (por ejemplo, 16 bits, como ocurre en la NDS) y la informacion que contiene cada entrada, es la misma que si especificaramos el color de cada pixel directamente (cosa que explico despues)
El mapa de imagen (o la pantalla), es un bloque de memoria
que representa un rectangulo con la imagen (ancho x alto) . La unidad (pixel) agrupa tantos bits como colores tenga la imagen y estos se suelen dibujar de izquierda a derecha y de arriba a abajo.
En ocasiones, el bitmap no se organiza de esa forma (caso del formato BMP que organiza la imagen de iaquierda a derecha y de abajo a arriba) y tambien hay que tener cuidado con otro detalle: algunos formatos, como el BMP, suelen utilizar un ancho de imagen que puede ser mayor que el de la imagen contenida, por razones de alineacion de memoria (BMP alinea a 4 bytes cada linea de pixeles, asi que tendriamos que hacer una operacion asi: ancho_bytes=(((ancho*bits_por_pixel)/8)+3) & ~3 que nos daria el ancho real alineado a 4 bytes)
Cuando trabajamos con imagenes, la manipulacion de bits se hace necesaria, pues muchas veces, se necesita traducir el color de origen al de destino.
Informacion de color directa por pixel
Bien, hasta ahora hemos hablado de indices de color y de la organizacion de los pixeles en el mapa de imagen, pero llega el momento de tocar la informacion real que guarda cada pixel.
En imagenes, se suelen utilizar dos espacios de color: YUV, en JPEG o MPEG, que en si mismo, es una forma de compresion pues almacena la informacion de dos o mas pixeles, dedicando una parte de informacion comun a todos ellos y otra parte particular a cada uno (la GameCube trabaja con este espacio de color), requiriendo una serie de "extrañas" formulas para convertir a RGB, y el espacio RGB que es mucho mas facil de comprender.
RGB representa los componentes de color Rojo (Red), Verde (Green) y Azul (Blue). En ocasiones, se le añade un componente de informacion extra, llamado Alpha, que se utiliza para efectos de translucidez principalmente y donde el rango va desde transparente a solido. En este caso se habla de RGBA.
Es posible que los componentes de color esten ordenados de otra forma. Por ejemplo, en el formato BMP, los componentes se ordenarian como BGR, o sea, justo al reves.
Por convencion, la primera letra representa los bits mas bajos de color y la ultima, los bits mas altos, mientrs que el numero que le sigue, representa el numero de bits de cada componente.
Estos son los tipos mas comunes:
Color 32 bits
Ancho: 4 bytes
Representacion: R8 G8 B8 A8
Nota: un byte por componente con valores de 0 a 255
Rango: 0->Negro y transparente, 0xffffffff Blanco, solido
Color 24 bits
Ancho: 3 bytes
Representacion: R8 G8 B8
Nota: un byte por componente con valores de 0 a 255
Rango: 0->Negro, 0xffffff Blanco
Color 16 bits
Ancho: 2 bytes
Representacion: R5 G6 B5
Nota: Valores R y B de 0 a 31. En G de 0 a 63
Rango: 0->Negro, 0xffff Blanco
Color 15 bits
Ancho: 2 bytes
Representacion: R5 G5 B5 o R5 G5 B5 A1
Nota: Valores R,G, B de 0 a 31. A puede ser 0 o 1 (transparente o solido)
Rango: 0->Negro y transparente, 0xffff Blanco, solido
Color 8 bits
Ancho: 1 byte
Representacion: Indice de paleta, de 0 a 255
Nota: Color indirecto, precisa una tabla con la paleta de colores
Macros de empaquetamiento de color
// color 32 bits, rango de componentes: 0 a 255
#define RGBA32(r,g,b,a) (r | (g<<8) | (b<<16) | (a<<24))
// color 16 bits, rango de componentes: 0 a 255
#define RGB16(r,g,b,a) (((b & 0xf8)<<8) | ((g & 0xfc)<<3) | ((r & 0xf8)>>3))
// color 15 bits+Alpha, rango de componentes: 0 a 255
#define RGBA16(r,g,b,a) (((a & 0x80)<<8) | ((b & 0xf8)<<7) | ((g & 0xf8)<<2) | ((r & 0xf8)>>3))
Chapando el tema
Si quieres cargar imagenes de forma directa, mi utilidad sprite_gen te permite exportar las imagenes de forma directa a lenguaje C/C++ (tabla de datos) para imagenes hasta 128x128 pixeles.
El formato BMP es muy sencillo y tienes informacion por ahí (eso si, ten en cuenta lo de la alineacion a 4 bytes de las lineas que explico arriba y que a 24 bits usa 3 bytes por pixel), si lo quieres implementar a mano y el formato JPEG tiene una libreria Open Source donde solo tienes que hacer mencion en tu programa que las estás utilizando y no te requiere los fuentes, mientras que SDL dispone de librerias de carga de imagenes, pero está sujeto a la licencia GPL.
Yo te recomendaria utilizar sprite_gen para obtener las imagenes de forma directa, si las quieres utilizar para un juego y para aprender a manipular de forma directa, el buffer de pantalla y que trataras de utilizar otro tipo de librerias que ya esten portadas a la maquina en la que trabajes, si quieres hacer usos mas complejos (visor de fotos, etc)
Todo lo que te he explicado aquí iba con la idea de que supieras entender no solo la carga de una imagen, si no su representacion en pantalla.
![[tadoramo]](/images/smilies/adora.gif "Adorando")
![[buuuaaaa]](/images/smilies/nuevos/triste_ani3.gif "a lágrima viva")