- Initial commit

source/draw.cpp

@@ -0,0 +1,177 @@
+#include "draw.h"
+#include <vector>
+#include "gif.h"
+#include <algorithm>
+
+namespace draw
+{
+    SDL_Window *win = nullptr;
+    SDL_Renderer *ren = nullptr;
+    SDL_Texture *tex = nullptr;
+
+    SDL_Texture *source = nullptr;
+    SDL_Texture *dest = nullptr;
+
+    std::vector<texture_t> textures;
+
+    uint32_t palette[16];
+
+    void init()
+    {
+        SDL_Init(SDL_INIT_VIDEO);
+        win = SDL_CreateWindow("DILEMMAKER v0.1", 1280, 960, 0);
+        ren = SDL_CreateRenderer(win, NULL);
+        tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 256, 192);
+        SDL_SetTextureScaleMode(tex, SDL_SCALEMODE_NEAREST);
+    }
+
+    void fillRect(int x, int y, int w, int h, uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+    {
+        SDL_SetRenderDrawColor(ren, r, g, b, a);
+        SDL_FRect rect {float(x), float(y), float(w), float(h)};
+        SDL_RenderFillRect(ren, &rect);
+    }
+
+    void setSource(SDL_Texture *texture)
+    {
+        source = texture;
+    }
+
+    void setDest(SDL_Texture *texture)
+    {
+        dest = texture;
+        SDL_SetRenderTarget(ren, dest);
+    }
+
+    void regenerateTexture(texture_t &texture)
+    {
+        if (texture.target) return;
+        uint32_t *argb;
+        int pitch;
+        SDL_LockTexture(texture.texture, NULL, (void**)&argb, &pitch);
+        for (int i=0; i<texture.w*texture.h; ++i) argb[i] = palette[texture.pixels[i]];
+        SDL_UnlockTexture(texture.texture);
+    }
+
+    int loadPalette(const char *filename)
+    {
+        FILE *fp = fopen(filename, "r");
+        if (!fp) return -1;
+
+        char header[32];
+        int version, count;
+
+        // Read and validate header
+        if (!fgets(header, sizeof(header), fp) || strncmp(header, "JASC-PAL", 8) != 0) {
+            fclose(fp);
+            return -2;
+        }
+
+        if (fscanf(fp, "%d\n%d\n", &version, &count) != 2 || count != 16) {
+            fclose(fp);
+            return -3;
+        }
+
+        for (int i = 0; i < 16; ++i) {
+            int r, g, b;
+            if (fscanf(fp, "%d %d %d\n", &b, &g, &r) != 3) {
+                fclose(fp);
+                return -4;
+            }
+            palette[i] = (0xFF << 24) | (r << 16) | (g << 8) | b;
+        }
+
+        fclose(fp);
+        regenerateTextures();
+        return 0; // Success
+    }
+
+    void regenerateTextures()
+    {
+        for (auto &tex : textures)
+        {
+            regenerateTexture(tex);
+        }
+    }
+
+    texture_t getTexture(const char *filename)
+    {
+        std::string name = filename;
+        for (auto tex : textures) if (tex.name == name) return tex;
+
+        FILE *f = fopen(filename, "rb");
+        fseek(f, 0, SEEK_END);
+        int file_size = ftell(f);
+        fseek(f, 0, SEEK_SET);
+        uint8_t *buffer = (uint8_t*)malloc(file_size);
+        fread(buffer, file_size, 1, f);
+        fclose(f);
+
+        uint16_t w, h;
+        uint8_t *pixels = gif::Load(buffer, &w, &h);
+        free(buffer);
+
+        SDL_Texture * tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, w, h);
+        SDL_SetTextureScaleMode(tex, SDL_SCALEMODE_NEAREST);
+
+        texture_t t;
+        t.name = filename;
+        t.texture = tex;
+        t.pixels = pixels;
+        t.w = w;
+        t.h = h;
+        regenerateTexture(t);
+        textures.push_back(t);
+
+        return t;
+    }
+
+    texture_t createTexture(const char* name, int w, int h, SDL_TextureAccess access)
+    {
+        SDL_Texture * tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, access, w, h);
+        SDL_SetTextureScaleMode(tex, SDL_SCALEMODE_NEAREST);
+
+        texture_t t;
+        t.name = name;
+        t.texture = tex;
+        if (access == SDL_TEXTUREACCESS_TARGET) {
+            t.target = true;
+        } else {
+            t.pixels = (uint8_t*)malloc(w*h);
+            for (int i=0; i<w*h; ++i) t.pixels[i] = 0x00000000;
+        }
+        t.w = w;
+        t.h = h;
+        regenerateTexture(t);
+        textures.push_back(t);
+
+        return t;
+    }
+
+    void deleteTexture(const char *name)
+    {
+        for (auto it = textures.begin(); it != textures.end(); ++it) {
+            if ((*it).name == name)
+            {
+                SDL_DestroyTexture((*it).texture);
+                free((*it).pixels);
+                textures.erase(it);
+                return;
+            }
+        }
+    }
+
+
+    void draw(int dx, int dy, int dw, int dh, int sx, int sy, int sw, int sh)
+    {
+        SDL_FRect src {float(sx), float(sy), float(sw), float(sh)};
+        SDL_FRect dst {float(dx), float(dy), float(dw), float(dh)};
+        SDL_RenderTexture(ren, source, &src, &dst);
+    }
+
+    void present()
+    {
+        SDL_RenderPresent(ren);
+    }
+
+}

source/draw.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <stdint.h>
+#include <SDL3/SDL.h>
+#include <string>
+
+namespace draw
+{
+    struct texture_t
+    {
+        std::string name;
+        SDL_Texture *texture {nullptr};
+        uint8_t     *pixels {nullptr};
+        int         w;
+        int         h;
+        bool        target {false};
+    };
+
+    void init();
+    void fillRect(int x, int y, int w, int h, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+    void setSource(SDL_Texture *texture);
+    void setDest(SDL_Texture *texture);
+
+    int loadPalette(const char *filename);
+    void regenerateTextures();
+    texture_t getTexture(const char *name);
+    texture_t createTexture(const char* name, int w, int h, SDL_TextureAccess access);
+    void deleteTexture(const char *name);
+
+    void draw(int dx, int dy, int dw, int dh, int sx, int sy, int sw, int sh);
+
+    void present();
+}

source/gif.h

@@ -0,0 +1,481 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+namespace gif
+{
+    #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* Load(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/main.cpp

@@ -0,0 +1,24 @@
+#include "draw.h"
+
+int main(int argc, char *argv[])
+{
+    draw::init();
+    draw::loadPalette("data/palette/sweetie-16.pal");
+    auto tex = draw::getTexture("data/tilesets/standard.gif");
+    draw::setSource(tex.texture);
+    auto mapa = draw::createTexture("mapa", 256, 192, SDL_TEXTUREACCESS_TARGET);
+    draw::setDest(mapa.texture);
+    for (int y=0; y<24; ++y)
+        for (int x=0; x<32; ++x)
+            draw::draw(x*8, y*8, 8, 8, 0, 0, 8, 8);
+    draw::setDest(nullptr);
+    draw::fillRect(0,0,1280,960, 0, 0, 255, 255);
+    draw::setSource(mapa.texture);
+    draw::draw(128, 96, 1024, 768, 0, 0, 256, 192);
+    draw::fillRect(0,100,40,760, 255, 255, 255, 128);
+    draw::present();
+
+    SDL_Delay(2000);
+
+    return 0;
+}