home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 2 / RISC_DISC_2.iso / pd_share / program / sprtools / c / spr3spr < prev    next >
Encoding:
Text File  |  1994-07-18  |  8.4 KB  |  250 lines
  1. /************************************************************************
  2.  *                                    *
  3.  * spr3spr.c                                *
  4.  *                                    *
  5.  * Converts between extended sprite format and                *
  6.  * three 8 bit red/green/blue plane sprites in a file            *
  7.  *                                    *
  8.  * Version 1.10 (15-Jul-1994)                        *
  9.  *                                    *
  10.  * (C) 1993/4 DEEJ Technology PLC                    *
  11.  *                                    *
  12.  ************************************************************************/
  13.  
  14. #include <stdlib.h>
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include "io.h"
  18. #include "sprite.h"
  19.  
  20.  
  21. int main(int argc, char **argv)
  22. {
  23.         FILE *inf, *outf, *errf;
  24.         int          i, j, x, y;
  25.         int          red_i, green_i, blue_i, in_i, out_i;
  26.         int          pal_size, spr_size;
  27.         uint         r, g, b, rgb;
  28.         uint         words[2];
  29.         char         name[3][12];
  30.         spr_info_str spr[4];
  31.         spritefile   sprite;
  32.     char         string[256];
  33.  
  34.         file_args(argc, argv, &inf, &outf, &errf);
  35.  
  36.         /* read first sprite from file */
  37.  
  38.         read_struct(LE, (BYTE*)&sprite, spritefile_descr, inf);
  39.  
  40.     if(sprite.offset != 16)
  41.         {
  42.                 fprintf(stderr,"Error: bad sprite header offset (corrupt or not a sprite?)\n");
  43.                 exit(1);
  44.         }
  45.  
  46.         mode_info(&spr[0], &sprite);
  47.         read_palette(&spr[0], sprite.sprite-44, inf);    
  48.  
  49.         if(sprite.number == 3)
  50.         {
  51.                 /*
  52.                  * if three sprites in file
  53.                  * read data from the first one
  54.                  * and then read the other two
  55.                  */
  56.  
  57.                 memcpy(name[0], sprite.name, 12);
  58.                 alloc_spr_data(&spr[0]);
  59.                 fread(spr[0].spr_data, spr[0].line_size, spr[0].Y, inf);
  60.                 
  61.                 for(i=1; i<3; i++)
  62.                 {
  63.                         /* WARNING ignoring possible gap between sprites */
  64.  
  65.                         read_struct(LE, (BYTE*)&sprite.next,
  66.                                         &spritefile_descr[3], inf);
  67.                         mode_info(&spr[i], &sprite);
  68.                         read_palette(&spr[i], sprite.sprite-44, inf);    
  69.                         memcpy(name[i], sprite.name, 12);
  70.                         alloc_spr_data(&spr[i]);
  71.                         fread(spr[i].spr_data,spr[i].line_size,spr[i].Y,inf);
  72.                 }
  73.  
  74.                 /* get indexes of red green and blue sprites */
  75.  
  76.                 red_i   = 0;
  77.                 green_i = 1;
  78.                 blue_i  = 2;
  79.                 out_i   = 3;
  80.  
  81.                 for(i=0; i<3; i++)
  82.                 {
  83.                         if(strncmp(name[i],"red",  12)==0) red_i  =i;
  84.                         if(strncmp(name[i],"green",12)==0) green_i=i;
  85.                         if(strncmp(name[i],"blue", 12)==0) blue_i =i;
  86.                 }
  87.  
  88.                 /*
  89.                  * make details of extended sprite 
  90.                  * and allocate line buffer only for memory conservation
  91.                  */
  92.  
  93.                 spr[out_i].X    = spr[0].X;
  94.                 spr[out_i].Y    = spr[0].Y;
  95.                 spr[out_i].Xasp = spr[0].Xasp;
  96.                 spr[out_i].Yasp = spr[0].Yasp;
  97.                 spr[out_i].pix  = 0;
  98.                 spr[out_i].bpp  = 24;
  99.  
  100.                 fill_info(&spr[out_i]);
  101.                 alloc_spr_line(&spr[out_i]);
  102.                 write_sprite_header(&spr[out_i], outf);
  103.  
  104.                 sprintf(string,"Generating sprite %dx%dx%d:",spr[out_i].X,
  105.                                                              spr[out_i].Y,
  106.                                                              spr[out_i].bpp);
  107.         progress_start(string);
  108.  
  109.                 for(y=0; y<spr[out_i].Y; y++)
  110.                 {
  111.                         for(x=0; x<spr[out_i].X; x++)
  112.                         {
  113.                                 r = read_pixel_val(&spr[red_i],  x,y);
  114.                                 g = read_pixel_val(&spr[green_i],x,y);
  115.                                 b = read_pixel_val(&spr[blue_i], x,y);
  116.  
  117.                                 rgb = (b<<24) | (g<<16) | (r<<8);
  118.  
  119.                                 write_pixel_val(&spr[out_i], x,0, rgb);
  120.                         }
  121.                         fwrite(spr[out_i].spr_data, spr[out_i].line_size, 1, outf);
  122.  
  123.                         progress(y,spr[out_i].Y);
  124.                 }
  125.                 progress_finish();
  126.  
  127.                 fclose(inf);
  128.                 fclose(outf);
  129.                 fclose(errf);
  130.         }
  131.         else
  132.         {
  133.                 /*
  134.                  * allocate line buffer only for extened sprite
  135.                  * copy details of input sprite to all 3 output sprites
  136.                  * and allocated full data buffers
  137.                  */
  138.  
  139.                 alloc_spr_line(&spr[0]);
  140.  
  141.                 in_i    = 0;
  142.                 red_i   = 1;
  143.                 green_i = 2;
  144.                 blue_i  = 3;
  145.  
  146.                 for(i=1; i<4; i++)
  147.                 {
  148.                         spr[i].X    = spr[in_i].X;
  149.                         spr[i].Y    = spr[in_i].Y;
  150.                         spr[i].Xasp = spr[in_i].Xasp;
  151.                         spr[i].Yasp = spr[in_i].Yasp;
  152.                         spr[i].pix  = 8;
  153.                         spr[i].bpp  = 8;
  154.  
  155.                         fill_info(&spr[i]);
  156.                         alloc_spr_data(&spr[i]);
  157.  
  158.                         /* make read/green/blue plane palette */
  159.  
  160.                         for(j=0; j<256; j++)
  161.                         {
  162.                                 spr[i].palette[j] = j * 0x01010100;
  163.                         }
  164.                 }
  165.  
  166.                 sprintf(string,"Generating triples %dx%dx8:",spr[in_i].X,
  167.                                  spr[in_i].Y);
  168.         progress_start(string);
  169.  
  170.                 for(y=0; y<spr[in_i].Y; y++)
  171.                 {
  172.                         fread(spr[in_i].spr_data, spr[in_i].line_size, 1, inf);
  173.  
  174.                         for(x=0; x<spr[in_i].X; x++)
  175.                         {
  176.                                 rgb = read_pixel_RGB(&spr[in_i],x,0);
  177.  
  178.                                 r = (rgb >>  8) & 0xFF;
  179.                                 g = (rgb >> 16) & 0xFF;
  180.                                 b = (rgb >> 24) & 0xFF;
  181.  
  182.                                 write_pixel_val(&spr[red_i],   x,y, r);
  183.                                 write_pixel_val(&spr[green_i], x,y, g);
  184.                                 write_pixel_val(&spr[blue_i],  x,y, b);
  185.                         }
  186.  
  187.                         progress(y,spr[in_i].Y);
  188.                 }
  189.  
  190.                 /* write tripple sprites */ 
  191.  
  192.                 out_i = red_i;
  193.  
  194.                 pal_size = spr[out_i].cols*8;
  195.                 spr_size = spr[out_i].line_size * spr[out_i].Y;
  196.  
  197.                 sprite.number = 3;
  198.                 sprite.offset = 16;
  199.                 sprite.free   = sprite.offset + (spr_size+pal_size+44)*3 ;
  200.  
  201.                 for(i=1; i<4; i++)
  202.                 {
  203.                         sprite.next   = spr_size + pal_size + 44;
  204.                         sprite.width  = spr[i].line_size/4 -1;
  205.                         sprite.height = spr[i].Y-1;
  206.                         sprite.left   = 0;
  207.                         sprite.right  = 31 - (spr[i].line_size*8 -
  208.                                               spr[i].X*spr[i].pix);
  209.                         sprite.sprite = pal_size + 44;
  210.                         sprite.mask   = sprite.sprite;
  211.                         sprite.mode   = spr[i].mode;
  212.  
  213.                         memset(sprite.name, 0, 12);
  214.  
  215.                         if(i==red_i)    strncpy(sprite.name,"red",12);
  216.                         if(i==green_i)  strncpy(sprite.name,"green",12);
  217.                         if(i==blue_i)   strncpy(sprite.name,"blue",12);
  218.  
  219.                         if(i==1)
  220.                         {
  221.                                 write_struct(LE, (BYTE*)&sprite,
  222.                                              spritefile_descr, outf);
  223.                         }
  224.                         else
  225.                         {
  226.                                 write_struct(LE, (BYTE*)&sprite.next,
  227.                                              &spritefile_descr[3], outf);
  228.                         }
  229.  
  230.                         for(j=0; j<spr[i].cols; j++)
  231.                         {
  232.                                 words[0] = endian(LE,spr[i].palette[j]);
  233.                                 words[1] = words[0];
  234.                                 fwrite((char*)words, 8, 1, outf);
  235.                         }
  236.  
  237.                         fwrite(spr[i].spr_data, spr[i].line_size,
  238.                                spr[i].Y, outf);
  239.                 } 
  240.  
  241.                 progress_finish();
  242.  
  243.                 fclose(inf);
  244.                 fclose(outf);
  245.                 fclose(errf);
  246.         }
  247.  
  248.         return(0);
  249. }
  250.