home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 2 / RISC_DISC_2.iso / pd_share / program / sprtools / c / clr2spr < prev    next >
Encoding:
Text File  |  1994-07-18  |  4.4 KB  |  150 lines
  1. /************************************************************************
  2.  *                                                                      *
  3.  * clr2spr.c                                                            *
  4.  *                                                                      *
  5.  * clear bitmap to extened sprite format                                *
  6.  *                                                                      *
  7.  * Version 2.10 (15-Jul-1994)                                           *
  8.  *                                                                      *
  9.  * (C) 1993 DEEJ Technology PLC                                         *
  10.  *                                                                      *
  11.  ************************************************************************/
  12.  
  13. #include <stdlib.h>
  14. #include <stdio.h>
  15. #include <string.h>
  16. #include "io.h"
  17. #include "sprite.h"
  18. #include "clear.h"
  19.  
  20.  
  21. int main(int argc, char** argv)
  22. {
  23.         FILE *inf, *outf, *errf;
  24.         int          i,x,y;
  25.         int          line_size;
  26.         int          shift;
  27.         uint         rgb, r,g,b;
  28.         uchar       *clr_buf;
  29.         spr_info_str spr;
  30.         clear_hdr    hdr;
  31.         char         string[256];
  32.  
  33.         file_args(argc, argv, &inf, &outf, &errf);
  34.  
  35.         /* read creator string */
  36.  
  37.         while(fgetc(inf) > 0);
  38.  
  39.         read_struct(LE, (BYTE*)&hdr, clear_hdr_descr, inf);
  40.  
  41.     if(hdr.width==0 || hdr.height==0 || hdr.bpp==0 || hdr.bpp>24)
  42.     {
  43.         fprintf(errf,"Corrupt or possibly not a clear file\n");
  44.         return(1);
  45.     }
  46.  
  47.         spr.X       = hdr.width;
  48.         spr.Y       = hdr.height;
  49.         spr.Xasp    = 1;
  50.         spr.Yasp    = 1;
  51.  
  52.     switch(hdr.bpp)
  53.     {
  54.         case 1:  spr.bpp = 1;  break;
  55.         case 2:  spr.bpp = 2;  break;
  56.         case 3:  spr.bpp = 4;  break;
  57.         case 4:  spr.bpp = 4;  break;
  58.         case 5:  spr.bpp = 8;  break;
  59.         case 6:  spr.bpp = 8;  break;
  60.         case 7:  spr.bpp = 8;  break;
  61.         case 8:  spr.bpp = 8;  break;
  62.         default:
  63.             /*
  64.               * for bpp >8 & <24 round down from 9,12,15,18,21,24
  65.               */
  66.             if(hdr.bpp>8 && hdr.bpp<=16)
  67.             {
  68.                     spr.bpp = 15;
  69.             }
  70.             if(hdr.bpp > 16)
  71.             {
  72.                     spr.bpp = 24;
  73.             }
  74.         break;
  75.     }
  76.  
  77.         fill_info(&spr);
  78.  
  79.         if(hdr.bpp <= 8)
  80.         {
  81.                 spr.has_palette = (1<<hdr.bpp);
  82.  
  83.                 for(i=0; i<spr.has_palette; i++)
  84.                 {
  85.                         r = fgetc(inf);
  86.                         g = fgetc(inf);
  87.                         b = fgetc(inf);
  88.  
  89.                         spr.palette[i] = (b<<24) + (g<<16) + (r<<8);
  90.                 }
  91.         }
  92.  
  93.         alloc_spr_data(&spr);
  94.  
  95.         line_size = (hdr.bpp<=8) ? hdr.width : hdr.width*3;
  96.  
  97.         if((clr_buf = (uchar*)malloc(line_size)) == 0)
  98.         {
  99.                 fprintf(errf,"Unable to allocate clear buffer\n");
  100.                 exit(1);
  101.         }
  102.  
  103.         sprintf(string,"Generating sprite %dx%dx%d:",spr.X,spr.Y,spr.bpp);
  104.         progress_start(string);
  105.  
  106.         shift = hdr.bpp/3;
  107.  
  108.         for(y=0; y<spr.Y; y++)
  109.         {
  110.                 fread(clr_buf, line_size, 1, inf);
  111.         
  112.                 for(x=0; x<spr.X; x++)
  113.                 {
  114.                         if(hdr.bpp <= 8)
  115.                         {
  116.                                 write_pixel_val(&spr, x, y, clr_buf[x]);
  117.                         }
  118.                         else
  119.                         {
  120.                                 r = clr_buf[x*3+0];
  121.                                 g = clr_buf[x*3+1];
  122.                                 b = clr_buf[x*3+2];
  123.  
  124.                                 r |= (r >> shift);
  125.                                 g |= (g >> shift);
  126.                                 b |= (b >> shift);
  127.  
  128.                                 if(hdr.bpp <= 16)
  129.                                 {
  130.                                         rgb = ((b & 0xF8) << 7) |
  131.                                               ((g & 0xF8) << 2) |
  132.                                               ((r & 0xF8) >> 3);
  133.                                 }
  134.                                 else
  135.                                 {
  136.                                         rgb = (b << 24) | (g << 16) | (r << 8);
  137.                                 }
  138.  
  139.                                 write_pixel_val(&spr, x, y, rgb);
  140.                         }
  141.                 }
  142.                 progress(y,spr.Y);
  143.         }
  144.  
  145.         write_sprite(&spr,outf);
  146.  
  147.  
  148.         progress_finish();
  149. }
  150.