Formato CEL

 
Hardware
Modo 13h
Retrazado Vertical
Primitivas
La Paleta
Pantallas Virtuales
Sprites
Tablas Prefedifinidas
Efectos
Texto
Formatos gráficos
Periféricos
Optimizaciones
Herramientas
Cursos
Links
Foro
Correo Electrónico
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
 
 
 

Bajar todo Bajar todo (59.2 Kb)


Volver a formatos gráficos
1
Hosted by www.Geocities.ws

1