la classe Texture ja suporta carregar gifs i paletes

source/common/gif.c

@@ -0,0 +1,478 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#define EXTENSION_INTRODUCER   0x21
+#define IMAGE_DESCRIPTOR       0x2C
+#define TRAILER                0x3B
+
+#define GRAPHIC_CONTROL        0xF9
+#define APPLICATION_EXTENSION  0xFF
+#define COMMENT_EXTENSION      0xFE
+#define PLAINTEXT_EXTENSION    0x01
+
+#define READ(dst, size) memcpy(dst, buffer, size); buffer += size
+
+typedef struct
+{
+    unsigned short width;
+    unsigned short height;
+    unsigned char fields;
+    unsigned char background_color_index;
+    unsigned char pixel_aspect_ratio;
+}
+screen_descriptor_t;
+
+typedef struct
+{
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+}
+rgb;
+
+typedef struct
+{
+    unsigned short image_left_position;
+    unsigned short image_top_position;
+    unsigned short image_width;
+    unsigned short image_height;
+    unsigned char fields;
+}
+image_descriptor_t;
+
+typedef struct
+{
+    unsigned char byte;
+    int prev;
+    int len;
+}
+dictionary_entry_t;
+
+typedef struct
+{
+    unsigned char extension_code;
+    unsigned char block_size;
+}
+extension_t;
+
+typedef struct
+{
+    unsigned char fields;
+    unsigned short delay_time;
+    unsigned char transparent_color_index;
+}
+graphic_control_extension_t;
+
+typedef struct
+{
+    unsigned char application_id[ 8 ];
+    unsigned char version[ 3 ];
+}
+application_extension_t;
+
+typedef struct
+{
+    unsigned short left;
+    unsigned short top;
+    unsigned short width;
+    unsigned short height;
+    unsigned char cell_width;
+    unsigned char cell_height;
+    unsigned char foreground_color;
+    unsigned char background_color;
+}
+plaintext_extension_t;
+
+//static unsigned short width = 0;
+//static unsigned short height = 0;
+//static unsigned char* uncompressed_data = NULL;
+
+void uncompress( int code_length,
+               const unsigned char *input,
+               int input_length,
+               unsigned char *out )
+{
+    //int maxbits;
+    int i, bit;
+    int code, prev = -1;
+    dictionary_entry_t *dictionary;
+    int dictionary_ind;
+    unsigned int mask = 0x01;
+    int reset_code_length;
+    int clear_code; // This varies depending on code_length
+    int stop_code;  // one more than clear code
+    int match_len;
+
+    clear_code = 1 << ( code_length );
+    stop_code = clear_code + 1;
+    // To handle clear codes
+    reset_code_length = code_length;
+
+    // Create a dictionary large enough to hold "code_length" entries.
+    // Once the dictionary overflows, code_length increases
+    dictionary = ( dictionary_entry_t * )
+    malloc( sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
+
+    // Initialize the first 2^code_len entries of the dictionary with their
+    // indices.  The rest of the entries will be built up dynamically.
+
+    // Technically, it shouldn't be necessary to initialize the
+    // dictionary.  The spec says that the encoder "should output a
+    // clear code as the first code in the image data stream".  It doesn't
+    // say must, though...
+    for ( dictionary_ind = 0;
+         dictionary_ind < ( 1 << code_length );
+         dictionary_ind++ )
+    {
+        dictionary[ dictionary_ind ].byte = dictionary_ind;
+        // XXX this only works because prev is a 32-bit int (> 12 bits)
+        dictionary[ dictionary_ind ].prev = -1;
+        dictionary[ dictionary_ind ].len = 1;
+    }
+
+    // 2^code_len + 1 is the special "end" code; don't give it an entry here
+    dictionary_ind++;
+    dictionary_ind++;
+
+    // TODO verify that the very last byte is clear_code + 1
+    while ( input_length )
+    {
+        code = 0x0;
+        // Always read one more bit than the code length
+        for ( i = 0; i < ( code_length + 1 ); i++ )
+        {
+            // This is different than in the file read example; that
+            // was a call to "next_bit"
+            bit = ( *input & mask ) ? 1 : 0;
+            mask <<= 1;
+
+            if ( mask == 0x100 )
+            {
+                mask = 0x01;
+                input++;
+                input_length--;
+            }
+
+            code = code | ( bit << i );
+        }
+
+        if ( code == clear_code )
+        {
+            code_length = reset_code_length;
+            dictionary = ( dictionary_entry_t * ) realloc( dictionary,
+                                                          sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
+
+            for ( dictionary_ind = 0;
+                 dictionary_ind < ( 1 << code_length );
+                 dictionary_ind++ )
+            {
+                dictionary[ dictionary_ind ].byte = dictionary_ind;
+                // XXX this only works because prev is a 32-bit int (> 12 bits)
+                dictionary[ dictionary_ind ].prev = -1;
+                dictionary[ dictionary_ind ].len = 1;
+            }
+            dictionary_ind++;
+            dictionary_ind++;
+            prev = -1;
+            continue;
+        }
+        else if ( code == stop_code )
+        {
+            /*if ( input_length > 1 )
+            {
+                fprintf( stderr, "Malformed GIF (early stop code)\n" );
+                exit( 0 );
+            }*/
+            break;
+        }
+
+        // Update the dictionary with this character plus the _entry_
+        // (character or string) that came before it
+        if ( ( prev > -1 ) && ( code_length < 12 ) )
+        {
+            if ( code > dictionary_ind )
+            {
+                fprintf( stderr, "code = %.02x, but dictionary_ind = %.02x\n",
+                        code, dictionary_ind );
+                exit( 0 );
+            }
+
+            // Special handling for KwKwK
+            if ( code == dictionary_ind )
+            {
+                int ptr = prev;
+
+                while ( dictionary[ ptr ].prev != -1 )
+                {
+                    ptr = dictionary[ ptr ].prev;
+                }
+                dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
+            }
+            else
+            {
+                int ptr = code;
+                while ( dictionary[ ptr ].prev != -1 )
+                {
+                    ptr = dictionary[ ptr ].prev;
+                }
+                dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
+            }
+
+            dictionary[ dictionary_ind ].prev = prev;
+
+            dictionary[ dictionary_ind ].len = dictionary[ prev ].len + 1;
+
+            dictionary_ind++;
+
+            // GIF89a mandates that this stops at 12 bits
+            if ( ( dictionary_ind == ( 1 << ( code_length + 1 ) ) ) &&
+                ( code_length < 11 ) )
+            {
+                code_length++;
+
+                dictionary = ( dictionary_entry_t * ) realloc( dictionary,
+                                                              sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
+            }
+        }
+
+        prev = code;
+
+        // Now copy the dictionary entry backwards into "out"
+        match_len = dictionary[ code ].len;
+        while ( code != -1 )
+        {
+            out[ dictionary[ code ].len - 1 ] = dictionary[ code ].byte;
+            if ( dictionary[ code ].prev == code )
+            {
+                fprintf( stderr, "Internal error; self-reference." );
+                exit( 0 );
+            }
+            code = dictionary[ code ].prev;
+        }
+
+        out += match_len;
+    }
+}
+
+static int read_sub_blocks( unsigned char* buffer, unsigned char **data )
+{
+    int data_length;
+    int index;
+    unsigned char block_size;
+
+    // Everything following are data sub-blocks, until a 0-sized block is
+    // encountered.
+    data_length = 0;
+    *data = NULL;
+    index = 0;
+
+    while ( 1 )
+    {
+		READ(&block_size, 1);
+
+        if ( block_size == 0 )  // end of sub-blocks
+        {
+            break;
+        }
+
+        data_length += block_size;
+        *data = (unsigned char*)realloc( *data, data_length );
+
+        // TODO this could be split across block size boundaries
+		READ(*data + index, block_size);
+
+        index += block_size;
+    }
+
+    return data_length;
+}
+
+unsigned char* process_image_descriptor( unsigned char* buffer,
+                                    rgb *gct,
+                                    int gct_size,
+                                    int resolution_bits )
+{
+    image_descriptor_t image_descriptor;
+    int compressed_data_length;
+    unsigned char *compressed_data = NULL;
+    unsigned char lzw_code_size;
+    int uncompressed_data_length = 0;
+    unsigned char *uncompressed_data = NULL;
+
+    // TODO there could actually be lots of these
+	READ(&image_descriptor, 9);
+
+    // TODO if LCT = true, read the LCT
+
+	READ(&lzw_code_size, 1);
+
+    compressed_data_length = read_sub_blocks( buffer, &compressed_data );
+
+//    width = image_descriptor.image_width;
+//    height = image_descriptor.image_height;
+    uncompressed_data_length = image_descriptor.image_width *
+    image_descriptor.image_height;
+    uncompressed_data = (unsigned char*)malloc( uncompressed_data_length );
+
+    uncompress( lzw_code_size, compressed_data, compressed_data_length,
+               uncompressed_data );
+
+    if ( compressed_data ) free( compressed_data );
+
+    //if ( uncompressed_data )
+    //    free( uncompressed_data );
+
+    return uncompressed_data;
+}
+
+/**
+ * @param gif_file the file descriptor of a file containing a
+ *  GIF-encoded file.  This should point to the first byte in
+ *  the file when invoked.
+ */
+#define rb (*(buffer++))
+
+uint32_t* LoadPalette(unsigned char *buffer) {
+	unsigned char header[7];
+	screen_descriptor_t screen_descriptor;
+	//int color_resolution_bits;
+
+	int global_color_table_size = 0;  // number of entries in global_color_table
+	uint32_t *global_color_table = NULL;
+
+	READ(header, 6);
+	READ(&screen_descriptor, 7);
+
+	//color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
+	global_color_table = (uint32_t *)calloc(1, 1024);
+
+	if (screen_descriptor.fields & 0x80) {
+		global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
+
+		//global_color_table = (rgb *)malloc(3 * global_color_table_size);
+		//READ(global_color_table, 3 * global_color_table_size);
+        for (int i=0; i<global_color_table_size;++i) {
+            global_color_table[i] = (buffer[0]<<16) + (buffer[1]<<8) + buffer[2];
+            buffer+=3;
+        }
+	}
+	return global_color_table;
+}
+
+static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short* w, unsigned short* h)
+{
+    unsigned char header[ 7 ];
+    screen_descriptor_t screen_descriptor;
+    int color_resolution_bits;
+
+    int global_color_table_size =0;  // number of entries in global_color_table
+    rgb *global_color_table = NULL;
+
+    unsigned char block_type = 0x0;
+
+    // A GIF file starts with a Header (section 17)
+	READ(header, 6);
+    header[ 6 ] = 0x0;
+
+    // XXX there's another format, GIF87a, that you may still find
+    // floating around.
+    /*if ( strcmp( "GIF89a", (char*)header ) )
+    {
+        fprintf( stderr,
+                "Invalid GIF file (header is '%s', should be 'GIF89a')\n",
+                header );
+        return NULL;
+    }*/
+
+    // Followed by a logical screen descriptor
+    // Note that this works because GIFs specify little-endian order; on a
+    // big-endian machine, the height & width would need to be reversed.
+
+    // Can't use sizeof here since GCC does byte alignment;
+    // sizeof( screen_descriptor_t ) = 8!
+	READ(&screen_descriptor, 7);
+    *w = screen_descriptor.width;
+    *h = screen_descriptor.height;
+
+    color_resolution_bits = ( ( screen_descriptor.fields & 0x70 ) >> 4 ) + 1;
+
+    if ( screen_descriptor.fields & 0x80 )
+    {
+        //int i;
+        // If bit 7 is set, the next block is a global color table; read it
+        global_color_table_size = 1 << 
+        ( ( ( screen_descriptor.fields & 0x07 ) + 1 ) );
+        
+        global_color_table = ( rgb * ) malloc( 3 * global_color_table_size );
+        
+        // XXX this could conceivably return a short count...
+		READ(global_color_table, 3 * global_color_table_size);
+    }
+    
+    while ( block_type != TRAILER )
+    {
+		READ(&block_type, 1);
+        
+        unsigned char size;
+        switch ( block_type )
+        {
+            case IMAGE_DESCRIPTOR:
+				return process_image_descriptor(buffer,
+					global_color_table,
+					global_color_table_size,
+					color_resolution_bits);
+                break;
+            case EXTENSION_INTRODUCER:
+                buffer++;
+                size = *(buffer++);
+                buffer += size;
+                do {
+                    size = *(buffer++);
+                    buffer += size;
+                } while (size != 0);
+
+                /*if ( !process_extension( buffer ) )
+                {
+                    return NULL;
+                }*/
+                break;
+            case TRAILER:
+                break;
+            default:
+                fprintf( stderr, "Bailing on unrecognized block type %.02x\n",
+                        block_type );
+                return NULL;
+        }
+    }
+	return NULL;
+}
+
+
+unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short* h) {
+	return process_gif_stream(buffer, w, h);
+}
+
+/*int main( int argc, char *argv[] )
+{
+    FILE* gif_file;
+    
+    if ( argc < 2 )
+    {
+        fprintf( stderr, "Usage: %s <path-to-gif-file>\n", argv[ 0 ] );
+        exit( 0 );
+    }
+    
+    gif_file = fopen( argv[ 1 ], "rb" );
+    
+    if ( gif_file == NULL )
+    {
+        fprintf( stderr, "Unable to open file '%s'", argv[ 1 ] );
+        perror( ": " );
+    }
+    
+    process_gif_stream( gif_file );
+    
+    fclose( gif_file );
+}*/

source/common/texture.cpp

@@ -2,6 +2,7 @@
 #include "texture.h"
 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h"
+#include "gif.c"
 #include <iostream>
 
 // Constructor
@@ -12,14 +13,36 @@ Texture::Texture(SDL_Renderer *renderer, std::string path, bool verbose)
 	this->path = path;
 
 	// Inicializa
+	surface = nullptr;
 	texture = nullptr;
 	width = 0;
 	height = 0;
+	for (int i = 0; i < 256; ++i)
+	{
+		paleta[i] = 0;
+	}
 
 	// Carga el fichero en la textura
 	if (path != "")
 	{
-		loadFromFile(path, renderer, verbose);
+		// Obtiene la extensión
+		const std::string extension = path.substr(path.find_last_of(".") + 1);
+
+		// .png
+		if (extension == "png")
+		{
+			loadFromFile(path, renderer, verbose);
+		}
+
+		// .gif
+		else if (extension == "gif")
+		{
+			surface = loadSurface(path.c_str());
+			loadPal(path.c_str());
+			setPal(0, 0x00000000);
+			createBlank(renderer, width, height);
+			flipSurface();
+		}
 	}
 }
 
@@ -109,10 +132,10 @@ bool Texture::loadFromFile(std::string path, SDL_Renderer *renderer, bool verbos
 }
 
 // Crea una textura en blanco
-bool Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access)
+bool Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_PixelFormatEnum format, SDL_TextureAccess access)
 {
 	// Crea una textura sin inicializar
-	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
+	texture = SDL_CreateTexture(renderer, format, access, width, height);
 	if (texture == nullptr)
 	{
 		std::cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << std::endl;
@@ -129,7 +152,7 @@ bool Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_Tex
 // Libera la memoria de la textura
 void Texture::unload()
 {
-	// Libera la textura si existe
+	// Libera la textura
 	if (texture != nullptr)
 	{
 		SDL_DestroyTexture(texture);
@@ -137,6 +160,13 @@ void Texture::unload()
 		width = 0;
 		height = 0;
 	}
+
+	// Libera la surface
+	if (surface != nullptr)
+	{
+		deleteSurface(surface);
+		surface = nullptr;
+	}
 }
 
 // Establece el color para la modulacion
@@ -206,3 +236,113 @@ SDL_Texture *Texture::getSDLTexture()
 {
 	return texture;
 }
+
+// Crea una nueva surface
+Surface Texture::newSurface(int w, int h)
+{
+	Surface surf = (Surface)malloc(sizeof(surface_s));
+	surf->w = w;
+	surf->h = h;
+	surf->data = (Uint8 *)malloc(w * h);
+	return surf;
+}
+
+// Elimina una surface
+void Texture::deleteSurface(Surface surface)
+{
+	if (surface == nullptr)
+	{
+		return;
+	}
+
+	if (surface->data != nullptr)
+	{
+		free(surface->data);
+	}
+
+	free(surface);
+}
+
+// Crea una surface desde un fichero .gif
+Surface Texture::loadSurface(const char *filename)
+{
+	FILE *f = fopen(filename, "rb");
+	if (!f)
+	{
+		return NULL;
+	}
+
+	fseek(f, 0, SEEK_END);
+	long size = ftell(f);
+	fseek(f, 0, SEEK_SET);
+	Uint8 *buffer = (Uint8 *)malloc(size);
+	fread(buffer, size, 1, f);
+	fclose(f);
+
+	Uint16 w, h;
+	Uint8 *pixels = LoadGif(buffer, &w, &h);
+	if (pixels == NULL)
+	{
+		return NULL;
+	}
+
+	Surface surface = (Surface)malloc(sizeof(surface_s));
+	surface->w = w;
+	surface->h = h;
+	surface->data = pixels;
+	free(buffer);
+
+	this->width = w;
+	this->height = h;
+
+	return surface;
+}
+
+// Vuelca la surface en la textura
+void Texture::flipSurface()
+{
+	Uint32 *pixels;
+	int pitch;
+	SDL_LockTexture(texture, nullptr, (void **)&pixels, &pitch);
+	for (int i = 0; i < width * height; ++i)
+	{
+		pixels[i] = paleta[surface->data[i]];
+	}
+	SDL_UnlockTexture(texture);
+}
+
+// Establece un color de la paleta
+void Texture::setPal(int index, Uint32 color)
+{
+	paleta[index] = color;
+}
+
+// Carga una paleta desde un fichero
+void Texture::loadPal(const char *filename)
+{
+	FILE *f = fopen(filename, "rb");
+	if (!f)
+	{
+		return;
+	}
+
+	fseek(f, 0, SEEK_END);
+	long size = ftell(f);
+	fseek(f, 0, SEEK_SET);
+	Uint8 *buffer = (Uint8 *)malloc(size);
+	fread(buffer, size, 1, f);
+	fclose(f);
+
+	Uint32 *pal = LoadPalette(buffer);
+	if (pal == NULL)
+	{
+		return;
+	}
+
+	free(buffer);
+
+	for (int i = 0; i < 256; ++i)
+	{
+		paleta[i] = (pal[i] << 8) + 255;
+	}
+}

source/common/texture.h

@@ -7,17 +7,46 @@
 #ifndef TEXTURE_H
 #define TEXTURE_H
 
+// Definiciones de tipos
+struct surface_s
+{
+    Uint8 *data;
+    Uint16 w, h;
+};
+
+typedef struct surface_s *Surface;
+
 class Texture
 {
 private:
     // Objetos y punteros
     SDL_Texture *texture;   // La textura
     SDL_Renderer *renderer; // Renderizador donde dibujar la textura
+    Surface surface;        // Surface para usar imagenes en formato gif con paleta
 
     // Variables
-    int width;        // Ancho de la imagen
+    int width;          // Ancho de la imagen
-    int height;       // Alto de la imagen
+    int height;         // Alto de la imagen
-    std::string path; // Ruta de la imagen de la textura
+    std::string path;   // Ruta de la imagen de la textura
+    Uint32 paleta[256]; // Paleta para la surface
+
+    // Crea una nueva surface
+    Surface newSurface(int w, int h);
+
+    // Elimina una surface
+    void deleteSurface(Surface surface);
+
+    // Crea una surface desde un fichero .gif
+    Surface loadSurface(const char *filename);
+
+    // Vuelca la surface en la textura
+    void flipSurface();
+
+    // Establece un color de la paleta
+    void setPal(int index, Uint32 color);
+
+    // Carga una paleta desde un fichero
+    void loadPal(const char *filename);
 
 public:
     // Constructor
@@ -30,7 +59,7 @@ public:
     bool loadFromFile(std::string path, SDL_Renderer *renderer, bool verbose = false);
 
     // Crea una textura en blanco
-    bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
+    bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_PixelFormatEnum format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
 
     // Libera la memoria de la textura
     void unload();

source/director.cpp

@@ -363,11 +363,11 @@ bool Director::setFileList()
 	asset->add(prefix + "/data/gfx/title_dust.png", t_bitmap);
 	asset->add(prefix + "/data/gfx/title_dust.ani", t_data);
 
-	asset->add(prefix + "/data/gfx/player1.png", t_bitmap);
+	asset->add(prefix + "/data/gfx/player1.gif", t_bitmap);
-	asset->add(prefix + "/data/gfx/player2.png", t_bitmap);
+	asset->add(prefix + "/data/gfx/player2.gif", t_bitmap);
 	asset->add(prefix + "/data/gfx/player.ani", t_data);
-	asset->add(prefix + "/data/gfx/player1_power.png", t_bitmap);
+	asset->add(prefix + "/data/gfx/player1_power.gif", t_bitmap);
-	asset->add(prefix + "/data/gfx/player2_power.png", t_bitmap);
+	asset->add(prefix + "/data/gfx/player2_power.gif", t_bitmap);
 	asset->add(prefix + "/data/gfx/player_power.ani", t_data);
 
 	// Fuentes de texto

source/game.cpp

@@ -453,19 +453,19 @@ void Game::loadMedia()
 	itemTextures.push_back(item6);
 
 	// Texturas - Player1
-	Texture *player1 = new Texture(renderer, asset->get("player1.png"));
+	Texture *player1 = new Texture(renderer, asset->get("player1.gif"));
 	player1Textures.push_back(player1);
 
-	Texture *player1Power = new Texture(renderer, asset->get("player1_power.png"));
+	Texture *player1Power = new Texture(renderer, asset->get("player1_power.gif"));
 	player1Textures.push_back(player1Power);
 
 	playerTextures.push_back(player1Textures);
 
 	// Texturas - Player2
-	Texture *player2 = new Texture(renderer, asset->get("player2.png"));
+	Texture *player2 = new Texture(renderer, asset->get("player2.gif"));
 	player2Textures.push_back(player2);
 
-	Texture *player2Power = new Texture(renderer, asset->get("player2_power.png"));
+	Texture *player2Power = new Texture(renderer, asset->get("player2_power.gif"));
 	player2Textures.push_back(player2Power);
 
 	playerTextures.push_back(player2Textures);