|
|
Este formato al
igual que el PIC, es originario del Animator Studio. Es muy utilizado para
guardar sprites, o mejor dicho imágenes pequeñas para juegos.
Este formato no posee ningún tipo de compresión. Esta organizado
de la siguiente forma:
Cabecera: 32 bytes
Paleta: 768 bytes
Imagen: ancho*alto bytes (Tamaño
máximo 320x200)
Total: ancho*alto+800 bytes
Hay que tener en cuenta que la cabecera
en este caso si va ser necesaria, ya que no todas las imágenes serán
de 320x200.
Cabecera:
0 byte: Numero mágico que
debe ser igual a 9119h
2 byte: Ancho de la imagen
4 byte: Alto de la imagen
6 byte: Posición horizontal
en la pantalla
8 byte: Posición vertical
en la pantalla
10 byte: Bits por pixel (Debe ser
igual a 8)
11 byte: Tipo de compresión
(0=no comprimido)
12 byte: Tamaño en bytes
de la imagen
16..32 byte: Reservados para futuras
ampliaciones
Al leer el archivo nos interesaran 3 cosas,
primero reconocer que sea un archivo Cel válido, para esto utilizaremos
el numero mágico, y también el ancho y alto de la imagen.
Veamos ahora como nos quedaría una
rutina para leer estos tipos de archivo. Ojo que BYTE equivale a un unsigned
char, y WORD es un unsigned int.
int LoadCel(char *filename,
t_paleta paleta, BYTE **where)
{
enum{ARCHIVO_NO_ENCONTRADO=0,
NO_HAY_MEMORIA=-1, NO_ES_CEL=-2, OK=1};
struct
{
WORD Magic_Number;
// Numero magico debe ser igual 0x9119
WORD Width;
// Ancho de la imagen
WORD Heigh;
// Alto de la imagen
WORD Horiz;
// Posicion horizontal
WORD Vert;
// Posicion vertical
BYTE BPP;
// Bits Por Pixel (8)
BYTE Compresion;
// Tipo de compresion (0=no comprimido)
long Size;
// Tamaño en bytes de la imagen
BYTE Reservados[16];
// Reservados para futuras ampliaciones
} CelHead;
FILE
*f;
if((f=fopen(filename,
"rb"))==NULL) return ARCHIVO_NO_ENCONTRADO;
//
Leemos la cabecera
fread(&CelHead,
sizeof(char), 32, f);
if(CelHead.Magic_Number!=0x9119)
{
fclose(f);
return NO_ES_CEL;
}
//
Se reserva memoria para guardar la imagen y 4 bytes mas para guardar
//
el ancho y el alto (2 bytes cada uno)
if((*where=(BYTE*)malloc((CelHead.Width*CelHead.Height)+4))==NULL)
{
fclose(f);
return NO_HAY_MEMORIA;
}
//
Guardamos los valores del ancho y el alto
memcpy(*where,
&CelHead.Width, 2);
memcpy(*where+2,
&CelHead.Height, 2);
//
Leemos la paleta
fread(paleta,
sizeof(char), 768, f);
//
Leemos la imagen y la copiamos a *where+4 despues del ancho y alto
fread(*where+4,
sizeof(char), (CelHead.Width*CelHead.Height), f);
fclose(f);
return
OK;
} |
Si se dan cuenta, no se le puede
pasar como parámetro una pantalla virtual, ya que se reservan exactamente
ancho*alto+4 bytes, por lo que si la imagen fuera de 320x200 necesitaríamos
64000 bytes mas los 4 bytes que son para guardar los datos de ancho y alto.
Esta forma se hacerlo es así, ya que la imagen se comportaría
como un sprite, así que para mostrarlo en pantalla se podría
usar la funcion PutSprite() que se vio en la sección Sprites.
Ejemplo
Librería gráfica:
vgalib.h
Muestra como cargar una imagen en formato
CEL
Ver
ejemplo
Volver
a formatos gráficos
|