Subversion Repositories diogenes

/***************************************************************************

 *   Copyright (C) 2008 by David Rigler   *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 *   This program is distributed in the hope that it will be useful,       *

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *

 *   GNU General Public License for more details.                          *

 *                                                                         *

 *   You should have received a copy of the GNU General Public License     *

 *   along with this program; if not, write to the                         *

 *   Free Software Foundation, Inc.,                                       *

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *

 ***************************************************************************/

#include <stdio.h>

unsigned char header[0x2A] = {

  0x00,0x01,0x01,0x00,0x00,0x08,0x00,0x18,

  0x00,0x00,0x00,0x00,0x80,0x02,0xE0,0x01,

  0x08,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,

  0x00,0xFF,0x00,0x00,0xFF,0xFF,0xC2,0x79,

  0x02,0xC2,0x5D,0xFC,0xFF,0xE8,0xA3,0xFF,

  0xFF,0xFF};

  FILE *vram_dump = 0;

  FILE *tgain = 0;

  typedef struct

  {

      unsigned int pix[4][8];

  } my_tile;

#define NR_TILES 96

#define VRAM_SIZE 8192

  int used_tiles = 0;

  my_tile tiles[96];

  unsigned char encoded(int tilenum)

  {

        int x = (tilenum%12) + 4;

        int y = tilenum/12;

    return (y << 4) | x;

  }

  unsigned char outoftiles = 0;

  unsigned char VRAM[VRAM_SIZE] = {0};

  unsigned char bitmap[640][480] = {0};

  unsigned char tileindex(int x_in, int y_in) {

    int x,y,i;

    my_tile t;

    int tilenum;

    for(y = 0; y < 8; y++){

      for(x = 0; x < 4; x++){

        t.pix[x][y] = (bitmap[x_in*8+2*x][y_in*8 + y] << 4) | bitmap[x_in*8+2*x+1][y_in*8 + y];

      }

    }

    int pissoff = 0;

    for(i = 0; i < used_tiles; i++) {

      pissoff = 0;

      for( x = 0; !pissoff && x < 4; x++)

        for( y = 0; !pissoff && y < 8; y++)

          if(tiles[i].pix[x][y] != t.pix[x][y])

            pissoff = 1;

      if(!pissoff){

        tilenum = i;

        break;

      }

    }

    if( i == used_tiles) {

                if(used_tiles >= NR_TILES) {

                        tilenum = 0;

                        outoftiles = 1;

                } else {

                  tilenum = used_tiles++;

                  for( x = 0;  x < 4; x++)

                        for( y = 0;  y < 8; y++)

                          tiles[tilenum].pix[x][y] = t.pix[x][y];

                }

        }

    return encoded(tilenum);

  }

  int main(int argc, char **argv) {

    int i; int x; int y;

    if(argc != 3)

      printf("usage: tga2dump [inputfile] [outputfile]\n");

    tgain = fopen(argv[1], "r");

    if(!tgain) {

      printf("input file");

      return 1;

    }

    vram_dump = fopen(argv[2], "w+");

    if(!vram_dump){

      printf("output file");

      return 1;

    }

  FILE *tgaout = fopen("debug.tga", "w+");

  if(!tgaout){

    printf("debug file");

    exit(1);

  }

    for(i = 1; i < NR_TILES; i++)

      for(y = 0; y < 8; y++)

                 for(x = 0; x < 4; x++)

                        tiles[i].pix[x][y] = 0x77;

  for(i = 0; i < 0x2A; i++) {

    fputc(header[i],tgaout);

  }

    fseek(tgain, 0x2A, SEEK_SET);

    for(y = 479; y >= 0; y--)

      for(x = 0; x < 640; x++)

        bitmap[x][y] = fgetc(tgain);

    for(y = 0; y < 60; y++)

      for(x = 0; x < 80; x++)

        VRAM[y*128 + x] = tileindex(x,y);

    for(i = 0; i < NR_TILES; i++)

      for(y = 0; y < 8; y++)

        for(x = 0; x < 4; x++)

          VRAM[128*( 8*(i/12) +y) + 80 + (i%12)*4 + x ] = tiles[i].pix[x][y];

    for(i = 0; i<VRAM_SIZE; i++)

      fputc(VRAM[i], vram_dump);

    // debug TILES

    for(i = 0; i < NR_TILES; i++)

      for(y = 0; y < 8; y++)

                 for(x = 0; x < 4; x++){

          bitmap[(i%12) * 9+2*x+1][200 + y + (i/12)*9] = tiles[i].pix[x][y] &0xf ;

                  bitmap[(i%12) * 9 + 2*x][200 + y + (i/12)*9] = tiles[i].pix[x][y]>>4;

                 }

     for(i = 0; i < NR_TILES; i++)

      for(y = 0; y < 8; y++)

                 for(x = 0; x < 4; x++){

          bitmap[(i%12) * 8+2*x +1+ 13*9][200 + y + (i/12)*8] = tiles[i].pix[x][y] &0xf ;

                  bitmap[(i%12) * 8 + 2*x + 13*9][200 + y + (i/12)*8] = tiles[i].pix[x][y]>>4;

                 }

   for(y = 479; y >= 0; y --)

    for(x = 0; x < 640; x++)

      fputc(bitmap[x][y], tgaout);

    fclose(vram_dump);

    fclose(tgain);

    fclose(tgaout);

        if(outoftiles)

          printf("to few tiles\n");

    return 0;

  }