Subversion Repositories orsoc_graphics_accelerator

/*
Per Lenander 2012
 
Bitmap font tool:
-----------------
 
The tool utilize SDL/SDL_image for graphics conversion
*/
 
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define SCREEN_DEPTH 32
 
#include <sstream>
#include <iostream>
#include <fstream>
#include <cstdlib>
 
using namespace std;
 
SDL_Surface *screen;
 
int spriteW = 0;
int spriteH = 0;
 
/* Ordinary inits */
int InitSDL(void)
{
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        cerr << "Unable to init SDL: " << SDL_GetError() << endl;
        return 1;
    }
 
    screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_DEPTH, SDL_HWSURFACE | SDL_DOUBLEBUF);
 
    if (!screen)
    {
        cerr << "Unable to set video: " << SDL_GetError() << endl;
        return 1;
    }
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    return 0;
}
 
/* Loads the spritesheet (or any image, but this is the only thing it is used for) */
SDL_Surface * LoadImage(std::string s)
{
    SDL_Surface *loaded = NULL;
 
    loaded = IMG_Load(s.c_str());
 
    if(!loaded)		return NULL;
 
    SDL_Surface *optimized = NULL;
 
    optimized = SDL_DisplayFormatAlpha(loaded);
 
    SDL_FreeSurface(loaded);
 
    if(!optimized)		return NULL;
 
    return optimized;
}
 
SDL_Color GetPixel ( SDL_Surface* pSurface , int x , int y )
{
  SDL_Color color ;
  Uint32 col = 0 ;
 
  //determine position
  char* pPosition = ( char* ) pSurface->pixels ;
 
  //offset by y
  pPosition += ( pSurface->pitch * y ) ;
 
  //offset by x
  pPosition += ( pSurface->format->BytesPerPixel * x ) ;
 
  //copy pixel data
  memcpy ( &col , pPosition , pSurface->format->BytesPerPixel ) ;
 
  //convert color
  SDL_GetRGB ( col , pSurface->format , &color.r , &color.g , &color.b ) ;
  return ( color ) ;
}
 
int main ( int argc, char** argv )
{
    if( argc < 2 )
    {
        cout << "Usage: " << argv[0] << " filename.<jpg/png/bmp> [bpp=16] [glyphsize=32]" << endl;
        return 1;
    }
 
    if( InitSDL() )
        return 1;
    cout << "SDL successfully initialized." << endl;
 
    SDL_Surface *spritesheet = LoadImage( argv[1] );
    if( spritesheet == NULL )
    {
        cout << "Couldn't load " << argv[1] << "!" << endl;
        return 1;
    }
 
    int outputBpp = 16;
    if(argc >= 3)
    {
        stringstream ss(argv[2]);
        ss >> outputBpp;
 
        if(outputBpp != 8 && outputBpp != 16 && outputBpp != 24 && outputBpp != 32)
        {
            cout << "Mode: '" << argv[2] << "' not supported, choose between 8, 16, 24, and 32" << endl;
            return 1;
        }
        else if(outputBpp == 8 && spritesheet->w % 4)
        {
            cout << "Mode: 8bpp requires the width to be divisible by 4!" << endl;
            return 1;
        }
        else if(outputBpp == 16 && spritesheet->w % 2)
        {
            cout << "Mode: 16bpp requires the width to be divisible by 2!" << endl;
            return 1;
        }
    }
 
    int stride = 1;
    if(outputBpp == 8)
        stride = 4;
    else if(outputBpp == 16)
        stride = 2;
 
    int glyphsize = 32;
    if(argc >= 4)
    {
        stringstream ss(argv[3]);
        ss >> glyphsize;
 
        if(glyphsize <= 0)
        {
            cout << "Negative glyph width not supported." << endl;
            return 1;
        }
    }
 
    string		filename(argv[1]);
    filename = filename.substr(0, filename.find('.'));
 
    /* Open an output file */
    string offilename = filename + "_font.h";
    ofstream	output(offilename.c_str(),ofstream::out);
    if( !output )
    {
        cout << "Couldn't open output file!" << endl;
        return 1;
    }
 
    SDL_Color bg = GetPixel(spritesheet, 0, 0);
 
    output << "/* Bitmap font definition */" << endl << endl;
    output << "/* size: " << spritesheet->w << " * " << spritesheet->h << " at " << outputBpp << "BPP */" << endl << endl;
    output << "#ifndef " << filename << "_H" << endl;
    output << "#define " << filename << "_H" << endl;
 
    output << "// Create the font with the following command:" << endl;
    output << "// -------------------------------------------" << endl;
    output << "orgfx_bitmap_font init_" << filename << "_font(int spacing, int spacewidth);" << endl << endl;
    output << "// SPACING refers to the number of pixels between characters in a string." << endl;
    output << "// SPACEWIDTH refers to the number of pixels used for the space char." << endl << endl;
 
 
    output << "// Write a string using this syntax:" << endl;
    output << "// ---------------------------------" << endl;
    output << "// orgfx_put_bitmap_text(&" << filename << "_font, x*FIXEDW, y*FIXEDW, \"Some text\");" << endl << endl;
 
    output << "orgfx_sprite_rect " << filename << "_glyphs[] = {" << endl;
 
    for(int glyphid = 0; glyphid < 256; glyphid++)
    {
        int startX = (glyphid%16) * glyphsize;
        int endX = startX + glyphsize;
        int startY = (glyphid/16) * glyphsize;
        int endY = startY + glyphsize;
 
        bool foundPixel = false;
 
        for(int x = endX-1; x >= startX; x--)
        {
            for(int y = startY; y < endY; y++)
            {
                SDL_Color col = GetPixel(spritesheet, x, y);
                if(col.r != bg.r || col.g != bg.g || col.b != bg.b)
                {
                    foundPixel = true;
                    break;
                }
            }
 
            if(foundPixel)
                break;
 
            endX--;
        }
 
        output << "{" << startX << ", " << startY << ", " << endX+1 << ", " << endY << "}, // " << glyphid << endl;
    }
 
    output << "};" << endl << endl;
 
    output << "unsigned int " << filename << "_img[] = {" << endl;
 
    for(int y = 0; y < spritesheet->h; y++)
    {
        for(int x = 0; x < spritesheet->w; x+=stride)
        {
            unsigned int pixel = 0;
            for(int s = 0; s < stride; s++)
            {
                SDL_Color c = GetPixel(spritesheet, x+s, y);
 
                if(outputBpp == 8)
                {
                    pixel += (unsigned char)(0.3 * c.r + 0.59 * c.g + 0.11 * c.b);
                    if(s != 3) pixel = pixel << 8;
                }
                else if(outputBpp == 16)
                {
                    c.r = c.r >> 3;
                    c.g = c.g >> 2;
                    c.b = c.b >> 3;
                    pixel += (c.r << 11) | (c.g << 5) | c.b;
                    if(s != 1) pixel = pixel << 16;
                }
                else
                    pixel = (c.r << 16) | (c.g << 8) | c.b;
            }
            output << pixel << "u, ";
        }
        output << endl;
    }
 
    output << "};" << endl << endl;
 
    output << "orgfx_tileset " << filename << "_ts;" << endl << endl;
 
    output << "orgfx_bitmap_font init_" << filename << "_font(int spacing, int spacewidth)" << endl;
    output << "{" << endl;
    output << "  int " << filename << "_surface = orgfxplus_init_surface(" << spritesheet->w << ", " << spritesheet->h << ", " << filename << "_img" << ");" << endl;
    output << "  " << filename << "_ts = orgfx_make_tileset(" << filename << "_surface, " << filename << "_glyphs, 256);" << endl;
    output << "  return orgfx_make_bitmap_font(&" << filename << "_ts, spacing, spacewidth);" << endl << endl;
    output << "}" << endl;
 
    output << "#endif // " << filename << "_H" << endl;
 
    output.close();
    SDL_FreeSurface( spritesheet );
 
    return 0;
}