home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / GRAPHICS / MISC / STK100.ZIP / SPREDSRC.COM / SPREDFIO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-20  |  8.3 KB  |  295 lines
  1. /**********************************************************************
  2. * spredfio.c
  3. * 
  4. * The sprite editor sprite data file IO
  5. **********************************************************************
  6.                     This file is part of
  7.  
  8.          STK -- The sprite toolkit -- version 1.0
  9.  
  10.               Copyright (C) Jari Karjala 1990
  11.  
  12. The sprite toolkit (STK) is a FreeWare toolkit for creating high
  13. resolution sprite graphics with PCompatible hardware. This toolkit 
  14. is provided as is without any warranty or such thing. See the file
  15. COPYING for further information.
  16.  
  17. **********************************************************************/
  18.  
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <stdlib.h>
  22. #include <ctype.h>
  23.  
  24. #include "grtypes.h"
  25. #include "spred.h"
  26.  
  27.  
  28. /**********************************************************************
  29. * Read the sprite map data from the given file.
  30. * First skip until a '{' character is reached, then
  31. * read w*h/8 bytes from the file.
  32. *
  33. * file    the file to use
  34. * smp     the sprite map to read the data into
  35. * w       the width of the map in pixels
  36. * h       the height of the map in pixels
  37. * xmap    if nonzero, then reading X11 bitmap (bits reversed)
  38. *
  39. * Return: 0 if all ok, negative otherwise
  40. **********************************************************************/
  41. int read_spred_map(FILE *file, SPRED_MAP smp, BYTE w, BYTE h, int xmap)
  42. {
  43.     int c, b, x,y,i;
  44.     
  45.     while ((c=fgetc(file))!=EOF && c!='{')
  46.         ;
  47.     
  48.     if (c!='{')
  49.         return -1;
  50.  
  51.     for (y=0; y<h; y++)
  52.         for (x=0; x<w; x+=8) {
  53.             if (fscanf(file, "%x", &b)!=1)      /* get one hex byte */
  54.                 return -2;
  55.             if (xmap)
  56.                 for (i=0; i<8; i++, b>>=1)          /* unpack X bitmap   */
  57.                     smp[x+i][y] = (((BYTE)b & 1) != 0);
  58.             else
  59.                 for (i=0; i<8; i++, b<<=1)          /* unpack sprite map */
  60.                     smp[x+i][y] = (((BYTE)b & (1<<7)) != 0);
  61.             c = fgetc(file);                    /* remove ',' */
  62.         }
  63.         
  64.     return 0;
  65. }
  66.  
  67. /**********************************************************************
  68. * Reads an sprite map file into the given internal data structure 
  69. * If no line starting with the string "/* SMP" is found, the file
  70. * is assumed to be an X11 bitmap.
  71. *
  72. * smpfile file to read the data from
  73. * sdp     pointer into the destination struct
  74. *
  75. * Return: sdp updated and 0 if no errors, negative otherwise
  76. **********************************************************************/
  77. int smp_to_spred_data(FILE *smpfile, SPRED_DATA *sdp)
  78. {
  79.     char buf[80], buf2[80];
  80.     int w,h,xmap;
  81.  
  82.     xmap = 1;
  83.     while ((fgets(buf, sizeof(buf), smpfile)!=NULL) && buf[0]!='#')
  84.         if (strncmp(buf, "/* SMP", 5)==0)
  85.             xmap = 0;
  86.  
  87.     if (buf[0]!='#')
  88.         return -1;
  89.     if (sscanf(buf, "%s %s %d\n", buf2, buf2, &w)!=3)
  90.         return -2;
  91.  
  92.     while ((fgets(buf, sizeof(buf), smpfile)!=NULL) && buf[0]!='#')
  93.         ;    
  94.     if (buf[0]!='#')
  95.         return -4;
  96.     if (sscanf(buf, "%s %s %d\n", buf2, buf2, &h)!=3)
  97.         return -5;
  98.     
  99.     if (w > MAX_SPRITE_WIDTH || h > MAX_SPRITE_HEIGHT)
  100.         return -6;
  101.     
  102.     if ((sdp->w | sdp->h) == 0) {   /* previous values zero, use new values */
  103.         sdp->w = w;
  104.         sdp->h = h;
  105.     }
  106.     
  107.     if (read_spred_map(smpfile, sdp->maps[SPR_SHAPE], w, h, xmap)<0)
  108.         return -7;
  109.     
  110.     if (!xmap)  /** X bitmaps has no mask map **/
  111.         if (read_spred_map(smpfile, sdp->maps[SPR_MASK], w, h, 0)<0)
  112.             return -8;
  113.     
  114.     return 0;
  115. }
  116.  
  117. /**********************************************************************
  118. * Load the sprite sdp->name. If sdp->h and sdp->w were non-zero
  119. * they are preserved, otherwise the read values are used.
  120. * Return: 0 if no errors, negative otherwise 
  121. *           (-1 fopen, -2 fread, -3 fclose error)
  122. **********************************************************************/
  123. int load_sprite(SPRED_DATA *sdp)
  124. {
  125.     FILE *fp;
  126.  
  127.     if ((fp=fopen(sdp->name, "r"))==NULL)
  128.         return -1;
  129.  
  130.     if (smp_to_spred_data(fp, sdp) < 0)
  131.         return -2;
  132.  
  133.     if (fclose(fp))
  134.         return -3;
  135.     
  136.     return 0;
  137. }
  138.  
  139. /**********************************************************************
  140. * Write the sprite map data from the given file
  141. *
  142. * file    the file to use
  143. * smp     the sprite map to write the data from
  144. * w       the width of the map in pixels
  145. * h       the height of the map in pixels
  146. *
  147. * Return: 0 if all ok, negative otherwise
  148. **********************************************************************/
  149. int write_spred_map(FILE *file, SPRED_MAP smp, BYTE w, BYTE h)
  150. {
  151.     int c, x,y,i;
  152.     BYTE b;
  153.     
  154.     for (c=0, y=0; y<h; y++)
  155.         for (x=0; x<w; x+=8) {
  156.             for (b=0, i=0; i<8; i++)            /* pack 8 bits into a byte */
  157.                 b = (b<<1) | smp[x+i][y];
  158.  
  159.             if ((c%12)==0)                      /* line start with a tab */
  160.                 fprintf(file, "\t");
  161.             
  162.             if (fprintf(file, "0x%02X,", b)<5)  /* output it */
  163.                 return -1;
  164.             
  165.             if (((++c) % 12)==0)                /* 12 bytes per line */
  166.                 fprintf(file, "\n");
  167.         }
  168.         
  169.     if ((c % 12)!=0)
  170.         fprintf(file, "\n");
  171.         
  172.     return 0;
  173. }
  174.  
  175. /**********************************************************************
  176. * Writes the given internal data structure into an sprite map file
  177. *
  178. * smpfile file to write the data to
  179. * sdp     pointer into the source struct
  180. *
  181. * Return: 0 if no errors, negative otherwise
  182. **********************************************************************/
  183. int spred_data_to_smp(FILE *smpfile, SPRED_DATA *sdp)
  184. {
  185.     char buf[SPR_NAME_LEN], *cp;
  186.  
  187.     /** take just the basename (no path, no extension) **/
  188.     if ((cp=strchr(sdp->name, '\\'))==NULL)
  189.         cp = sdp->name-1;
  190.     strcpy(buf, cp+1);
  191.     if ((cp=strchr(buf, '.'))!=NULL)
  192.         *cp = '\0';
  193.     for (cp=buf; *cp; cp++)
  194.         if (isupper(*cp))
  195.             *cp = tolower(*cp);
  196.     
  197.     fprintf(smpfile,
  198.         "/* SMP1  Sprite shape and mask bitmaps created by the SPRED */\n\n");
  199.     
  200.     fprintf(smpfile, "#define %s_width  %d\n", buf, sdp->w);
  201.     fprintf(smpfile, "#define %s_height %d\n", buf, sdp->h);
  202.     
  203.     fprintf(smpfile, "\nunsigned char %s_shape[] = {\n", buf);
  204.     if (write_spred_map(smpfile, sdp->maps[SPR_SHAPE], sdp->w, sdp->h)<0)
  205.         return -1;
  206.     fprintf(smpfile, "};\n");
  207.     
  208.     fprintf(smpfile, "unsigned char %s_mask[] = {\n", buf);
  209.     if (write_spred_map(smpfile, sdp->maps[SPR_MASK], sdp->w, sdp->h)<0)
  210.         return -1;
  211.     fprintf(smpfile, "};\n");
  212.  
  213.     return 0;
  214. }
  215.  
  216. /**********************************************************************
  217. * Save the given sprite.
  218. * Return: 0 if no errors, negative otherwise
  219. *           (-1 fopen, -2 fwrite, -3 fclose error)
  220. **********************************************************************/
  221. int save_sprite(SPRED_DATA *sdp)
  222. {
  223.     FILE *fp;
  224.  
  225.     if ((fp=fopen(sdp->name, "w"))==NULL)
  226.         return -1;
  227.  
  228.     if (spred_data_to_smp(fp, sdp) < 0)
  229.         return -2;
  230.  
  231.     if (fclose(fp))
  232.         return -3;
  233.     
  234.     return 0;
  235. }
  236.  
  237.  
  238. #ifdef TEST
  239.  
  240. SPRED_DATA sd;
  241.  
  242. void main(int argc, char **argv)
  243. {
  244.     char buf[50], *cp;
  245.     int i,j;
  246.     FILE *fp;
  247.     
  248.     if (argc<2)
  249.         exit(1);
  250.     
  251.     strcpy(buf, argv[1]);
  252.     strcpy(sd.name, argv[1]);
  253.     
  254.     if ((cp=strrchr(sd.name, '.'))!=NULL)
  255.         *cp='\0';
  256.     
  257.     if ((fp=fopen(buf, "r"))==NULL) {
  258.         perror("main");
  259.         exit(2);
  260.     }
  261.  
  262.     if ((i=smp_to_spred_data(fp, &sd))<0) {
  263.         fprintf(stderr, "main:smp_to_spred_data failed, code %d", i);
  264.         exit(3);
  265.     }
  266.     
  267.     fclose(fp);
  268.     
  269.     for (i=0; i<sd.h; i++) {
  270.         for (j=0; j<sd.w; j++)
  271.             putchar(sd.shape[j][i]+'0');
  272.         putchar('\n');
  273.     }
  274.     for (i=0; i<sd.h; i++) {
  275.         for (j=0; j<sd.w; j++)
  276.             putchar(sd.mask[j][i]+'0');
  277.         putchar('\n');
  278.     }
  279.  
  280.     
  281.     if ((fp=fopen(sd.name, "w"))==NULL) {
  282.         perror("main");
  283.         exit(4);
  284.     }
  285.  
  286.     if ((i=spred_data_to_smp(fp, &sd))<0) {
  287.         fprintf(stderr, "main:spred_data_to_smp failed, code %d", i);
  288.         exit(5);
  289.     }
  290.     fclose(fp);
  291.     
  292. }
  293.  
  294. #endif
  295.