home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / sprites / spredsrc / spred.c next >
Encoding:
C/C++ Source or Header  |  1991-02-25  |  15.9 KB  |  467 lines
  1. /**********************************************************************
  2. * spred.c
  3. * 
  4. * The sprite editor for the Sprite support system, main module.  
  5. **********************************************************************
  6.                     This file is part of
  7.  
  8.          STK -- The sprite toolkit -- version 1.1
  9.  
  10.               Copyright (C) Jari Karjala 1991
  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 <stdarg.h>
  23. #include <ctype.h>
  24. #include <math.h>
  25. #include <graphics.h>
  26.  
  27. #include "grtypes.h"
  28. #include "gr.h"
  29. #include "mouse.h"
  30.  
  31. #include "spred.h"
  32. #include "spredio.h"
  33. #include "spredfio.h"
  34.  
  35. #define TRUE 1
  36. #define FALSE 0
  37. #define FILE_EXTENSION ".smp"
  38.  
  39. /**********************************************************************
  40. *  Temporary map for various transformations
  41. **********************************************************************/
  42. SPRED_MAP temp_map;
  43.  
  44. /**********************************************************************
  45. * The user supplied width, height of the sprite
  46. **********************************************************************/
  47. int width=0, height=0;
  48.  
  49. /**********************************************************************
  50. * FATAL ERROR: Close graphics, print error and exit.
  51. **********************************************************************/
  52. void error(char *s,...)
  53. {
  54.     char buf[100];
  55.     va_list argptr;
  56.  
  57.     va_start(argptr,s);
  58.     vsprintf(buf,s,argptr);
  59.     va_end(argptr);
  60.     
  61.     closegraph();
  62.     fputs(buf, stderr);
  63.     exit(10);
  64. }
  65.  
  66. /**********************************************************************
  67. * Prints explanation for the error code returned by the sprite file IO
  68. * Return: the parameter e
  69. **********************************************************************/
  70. int file_error(int e, char *filename)
  71. {
  72.     static char *msgs[] = {
  73.         "Error in closing file %s",
  74.         "Sprite file is not complete",
  75.         "Cannot find file %s",
  76.         ""
  77.     };
  78.  
  79.     message(msgs[3+e], filename);
  80.     return e;
  81. }
  82.  
  83. /**********************************************************************
  84. * Inverts the givent sprite's active bitmap
  85. **********************************************************************/
  86. void invert(SPRED_DATA *sdp)
  87. {
  88.     int i,j;
  89.     
  90.     for(i=0; i<sdp->w; i++)
  91.         for(j=0; j<sdp->h; j++)
  92.             if (sdp->maps[sdp->map][i][j] == DOT_FOREGROUND)
  93.                 sdp->maps[sdp->map][i][j] = DOT_BACKGROUND;
  94.             else
  95.                 sdp->maps[sdp->map][i][j] = DOT_FOREGROUND;
  96. }
  97.  
  98. /**********************************************************************
  99. * Rotate the given sprites active bitmap 90 degrees anticlockwise
  100. **********************************************************************/
  101. void rotate_90(SPRED_DATA *sdp)
  102. {
  103.     int i,j, lim, tmp;
  104.     
  105.     if (sdp->w > sdp->h)
  106.         lim = sdp->h-1;
  107.     else
  108.         lim = sdp->w-1;
  109.     
  110.     for(i=0; i<(lim+1)/2; i++)
  111.         for(j=0; j<(lim+1)/2; j++) {
  112.             tmp = sdp->maps[sdp->map][i][j];
  113.             
  114.             sdp->maps[sdp->map][i][j]
  115.                 = sdp->maps[sdp->map][lim - j][i];
  116.             
  117.             sdp->maps[sdp->map][lim - j][i]
  118.                 = sdp->maps[sdp->map][lim - i][lim - j];
  119.             
  120.             sdp->maps[sdp->map][lim - i][lim - j]
  121.                 = sdp->maps[sdp->map][j][lim - i];
  122.             
  123.             sdp->maps[sdp->map][j][lim - i]
  124.                 = tmp;
  125.         }
  126. }
  127.  
  128. /**********************************************************************
  129. * Rotate the active map 'angle' degrees anticlockwise.
  130. * The transformation is done in reverse order, ie the points in the
  131. * destination bitmap are projected into the source bitmap. This
  132. * usually produces better rotations.
  133. * NOTE: uses the global temp_map
  134. **********************************************************************/
  135. void rotate(SPRED_DATA *sdp, double angle)
  136. {
  137.     int i,j, i1,j1;
  138.     double s,c,xo,yo;
  139.     
  140.     angle = M_PI*angle/180;
  141.     s = sin(angle);
  142.     c = cos(angle);
  143.     xo = (sdp->w - 1)/2.0;
  144.     yo = (sdp->h - 1)/2.0;
  145.     for(i=0; i < sdp->w; i++)
  146.         for(j=0; j < sdp->h; j++) {
  147.             i1 = (c*(i - xo) - s*(j - yo)) + xo;
  148.             j1 = (s*(i - xo) + c*(j - yo)) + yo;
  149.             if (i1>=0 && i1<sdp->w && j1>=0 && j1<sdp->h)
  150.                 temp_map[i][j] = sdp->maps[sdp->map][i1][j1];
  151.             else
  152.                 temp_map[i][j] = DOT_BACKGROUND;
  153.         }
  154.     memcpy(sdp->maps[sdp->map], temp_map, sizeof(temp_map));
  155. }
  156.  
  157. /**********************************************************************
  158. * Make part of the given sprite's active map fatter.
  159. * If a point's color is 'mid' and it has a neighbour which is in color
  160. * 'border', then the point's color is changed to 'border'.
  161. * NOTE: uses the global temp_map
  162. **********************************************************************/
  163. void make_fatter(SPRED_DATA *sdp, int mid, int border)
  164. {
  165.     int i,j;
  166.     
  167.     for(i=0; i < sdp->w; i++)
  168.         for(j=0; j < sdp->h; j++) {
  169.             if (   sdp->maps[sdp->map][i][j]==mid
  170.                 && (  (i > 0 && sdp->maps[sdp->map][i-1][j]==border)
  171.                     ||(j > 0 && sdp->maps[sdp->map][i][j-1]==border)
  172.                     ||(i < sdp->w-1 && sdp->maps[sdp->map][i+1][j]==border)
  173.                     ||(j < sdp->h-1 && sdp->maps[sdp->map][i][j+1]==border)))
  174.                         temp_map[i][j] = border;
  175.                     else
  176.                         temp_map[i][j] = sdp->maps[sdp->map][i][j];
  177.         }
  178.     memcpy(sdp->maps[sdp->map], temp_map, sizeof(temp_map));
  179. }
  180.  
  181.  
  182. /**********************************************************************
  183. * Load the sprite from the given file. If filename is a null string,
  184. * then the sdp->name is used.
  185. **********************************************************************/
  186. void load(SPRED_DATA *sdp, char *filename)
  187. {
  188.     sdp->w = width;
  189.     sdp->h = height;
  190.     if (filename[0]!='\0')
  191.         strcpy(sdp->name, filename);
  192.     if (strrchr(sdp->name, '.')==NULL)
  193.         strcat(sdp->name, FILE_EXTENSION);
  194.     message("Loading %s", sdp->name);
  195.     if (file_error(load_sprite(sdp), sdp->name)==0)
  196.         message("File: %s  Size: %dx%d", sdp->name, sdp->w, sdp->h);
  197.     else if ((sdp->w | sdp->h) == 0) {
  198.         sdp->w = 32;
  199.         sdp->h = 24;
  200.     }
  201.     draw_screen(sdp);
  202. }
  203.  
  204. /**********************************************************************
  205. * Edit the given sprite. The screen must be in graphics mode and
  206. * the mouse interface must be functional.
  207. * 
  208. * Return: 0 if normal exit with save, negative if quit
  209. **********************************************************************/
  210. int spred_edit(SPRED_DATA *sdp, int filec, char **filev)
  211. {
  212.     char buf[SPR_NAME_LEN];
  213.     MSG msg;
  214.     int x,y, ox, oy, i,j, tmp, quit, curfile;
  215.     static double angle = 30.0;
  216.  
  217.     sdp->map = SPR_SHAPE;
  218.  
  219.     curfile = 0;
  220.     load(sdp, filev[curfile]);
  221.     
  222.     quit = FALSE;
  223.     ox = oy = -1;
  224.     while (!quit) {
  225.         msg=get_msg(sdp, &x,&y);
  226.         switch (msg) {
  227.             case MSG_QUIT:
  228.                 quit = TRUE;
  229.                 break;
  230.                 
  231.             case MSG_EXIT:
  232.                 if (file_error(save_sprite(sdp), sdp->name)==0)
  233.                     quit = TRUE;
  234.                 break;
  235.  
  236.             case MSG_SAVE:
  237.                 message("Give the save filename [%s]:", sdp->name);
  238.                 if (gr_gets(buf, SPR_NAME_LEN)!=NULL) {
  239.                     if (buf[0]!='\0')
  240.                         strcpy(sdp->name, buf);
  241.                     if (strrchr(sdp->name, '.')==NULL)
  242.                         strcat(sdp->name, FILE_EXTENSION);
  243.                     message("Saving %s", sdp->name);
  244.                     file_error(save_sprite(sdp), sdp->name);
  245.                 }
  246.                 else
  247.                     message("");
  248.                 break;
  249.                 
  250.             case MSG_LOAD:
  251.                 message("Give the load filename [%s]:", sdp->name);
  252.                 if (gr_gets(buf, SPR_NAME_LEN)!=NULL)
  253.                     load(sdp, buf);
  254.                 else
  255.                     message("");
  256.                 break;
  257.                 
  258.             case MSG_NEXT:
  259.                 if (curfile+1 < filec)
  260.                     load(sdp, filev[++curfile]);
  261.                 else
  262.                     message("No more sprites");
  263.                 break;
  264.                 
  265.             case MSG_PREV:
  266.                 if (curfile > 0)
  267.                     load(sdp, filev[--curfile]);
  268.                 else
  269.                     message("No previous sprites");
  270.                 break;
  271.                 
  272.             case MSG_CLEAR:
  273.                 memset(sdp->maps[sdp->map], DOT_BACKGROUND,sizeof(SPRED_MAP));
  274.                 draw_map(sdp, sdp->map);
  275.                 break;
  276.                 
  277.             case MSG_COPY_TO_SHAPE:
  278.                 memcpy(sdp->maps[SPR_SHAPE], sdp->maps[SPR_MASK], 
  279.                        sizeof(sdp->maps[sdp->map]));
  280.                 sdp->map = SPR_SHAPE;
  281.                 invert(sdp);
  282.                 draw_map(sdp, SPR_SHAPE);
  283.                 break;
  284.                 
  285.             case MSG_COPY_TO_MASK:
  286.                 memcpy(sdp->maps[SPR_MASK], sdp->maps[SPR_SHAPE], 
  287.                        sizeof(sdp->maps[sdp->map]));
  288.                 sdp->map = SPR_MASK;
  289.                 invert(sdp);
  290.                 draw_map(sdp, SPR_MASK);
  291.                 break;
  292.                 
  293.             case MSG_ACTIVATE_MASK:
  294.                 sdp->map = SPR_MASK;
  295.                 draw_map(sdp, sdp->map);
  296.                 break;
  297.                 
  298.             case MSG_ACTIVATE_SHAPE:
  299.                 sdp->map = SPR_SHAPE;
  300.                 draw_map(sdp, sdp->map);
  301.                 break;
  302.  
  303.             /***** Point drawing functions *****/
  304.             case MSG_BTN1_CLICK:    /** set point **/
  305.                 sdp->maps[sdp->map][x][y] = DOT_FOREGROUND;
  306.                 draw_point(sdp, x, y, sdp->map);
  307.                 message("Last point: X=%d Y=%d", x,y);
  308.                 break;
  309.                 
  310.             case MSG_BTN2_CLICK:    /** flip point **/
  311.                 if (x!=ox || y!=oy) {
  312.                     if (sdp->maps[sdp->map][x][y] == DOT_FOREGROUND)
  313.                         sdp->maps[sdp->map][x][y] = DOT_BACKGROUND;
  314.                     else
  315.                         sdp->maps[sdp->map][x][y] = DOT_FOREGROUND;
  316.                     draw_point(sdp, x, y, sdp->map);
  317.                 }
  318.                 message("Last point: X=%d Y=%d", x,y);
  319.                 break;
  320.                 
  321.             case MSG_BTN3_CLICK:    /** clear point **/
  322.                 sdp->maps[sdp->map][x][y] = DOT_BACKGROUND;
  323.                 draw_point(sdp, x, y, sdp->map);
  324.                 message("Last point: X=%d Y=%d", x,y);
  325.                 break;
  326.  
  327.  
  328.             /***** Image manipulation commands *****/
  329.             case MSG_INVERT:
  330.                 invert(sdp);
  331.                 draw_map(sdp, sdp->map);
  332.                 break;
  333.  
  334.             case MSG_OVERLAY:
  335.                 draw_map(sdp, sdp->map | DOT_OVERLAY);
  336.                 break;
  337.  
  338.             case MSG_ROTATE90:
  339.                 rotate_90(sdp);
  340.                 draw_map(sdp, sdp->map);
  341.                 break;
  342.  
  343.             case MSG_ROTATE:
  344.                 message("Give rotation angle [%.1lf]:", angle);
  345.                 if (gr_gets(buf, sizeof(buf))!=NULL) {
  346.                     if (buf[0]!='\0')
  347.                         angle = atof(buf);
  348.                     rotate(sdp, angle);
  349.                     draw_map(sdp, sdp->map);
  350.                 }
  351.                 message("");                
  352.                 break;
  353.  
  354.             case MSG_HFLIP:
  355.                 for(i=0; i<sdp->w/2; i++)
  356.                     for(j=0; j<sdp->h; j++) {
  357.                         tmp = sdp->maps[sdp->map][sdp->w - i - 1][j];
  358.                         sdp->maps[sdp->map][sdp->w - i - 1][j]
  359.                             = sdp->maps[sdp->map][i][j];
  360.                         sdp->maps[sdp->map][i][j] = tmp;
  361.                     }
  362.                 draw_map(sdp, sdp->map);
  363.                 break;
  364.                 
  365.             case MSG_VFLIP:
  366.                 for(i=0; i<sdp->w; i++)
  367.                     for(j=0; j<sdp->h/2; j++) {
  368.                         tmp = sdp->maps[sdp->map][i][sdp->h - j - 1];
  369.                         sdp->maps[sdp->map][i][sdp->h - j - 1]
  370.                             = sdp->maps[sdp->map][i][j];
  371.                         sdp->maps[sdp->map][i][j] = tmp;
  372.                     }
  373.                 draw_map(sdp, sdp->map);
  374.                 break;
  375.                 
  376.             case MSG_HMIRROR:
  377.                 for(i=0; i<sdp->w/2; i++)
  378.                     for(j=0; j<sdp->h; j++) {
  379.                         tmp = sdp->maps[sdp->map][sdp->w - i - 1][j];
  380.                         if (sdp->maps[sdp->map][i][j]==DOT_FOREGROUND)
  381.                             sdp->maps[sdp->map][sdp->w - i - 1][j]
  382.                                 = sdp->maps[sdp->map][i][j];
  383.                         if (tmp==DOT_FOREGROUND)
  384.                             sdp->maps[sdp->map][i][j] = tmp;
  385.                     }
  386.                 draw_map(sdp, sdp->map);
  387.                 break;
  388.                 
  389.             case MSG_VMIRROR:
  390.                 for(i=0; i<sdp->w; i++)
  391.                     for(j=0; j<sdp->h/2; j++) {
  392.                         tmp = sdp->maps[sdp->map][i][sdp->h - j - 1];
  393.                         if (sdp->maps[sdp->map][i][j]==DOT_FOREGROUND)
  394.                             sdp->maps[sdp->map][i][sdp->h - j - 1]
  395.                                 = sdp->maps[sdp->map][i][j];
  396.                         if (tmp==DOT_FOREGROUND)
  397.                             sdp->maps[sdp->map][i][j] = tmp;
  398.                     }
  399.                 draw_map(sdp, sdp->map);
  400.                 break;                
  401.                 
  402.             case MSG_FATTER:
  403.                 make_fatter(sdp, DOT_BACKGROUND, DOT_FOREGROUND);
  404.                 draw_map(sdp, sdp->map);
  405.                 break;
  406.  
  407.             case MSG_THINNER:
  408.                 make_fatter(sdp, DOT_FOREGROUND, DOT_BACKGROUND);
  409.                 draw_map(sdp, sdp->map);
  410.                 break;
  411.  
  412.             case MSG_NONE:
  413.                 break;
  414.                 
  415.             default:
  416.                 message("Message %d not implemented", msg, x, y);
  417.         }
  418.         ox = x;
  419.         oy = y;
  420.     }
  421.     
  422.     return -(msg == MSG_QUIT);
  423. }
  424.  
  425.  
  426. /**********************************************************************
  427. * The sprite to be edited. Must be global, since the structure
  428. * take about 20 kBytes. It is automatically initialized to zero.
  429. **********************************************************************/
  430. SPRED_DATA sd;
  431.  
  432. void main(int argc, char **argv)
  433. {
  434.     int i,j;
  435.     
  436.     puts("SPRED -- Sprite editor v1.1 -- Copyright (C) 1991 Jari Karjala");
  437.     
  438.     if (argc<2 || (argc==2 && argv[1][0]=='-'))
  439.         error("\nUSAGE: SPRED [-WxH] sprite[.ext] [...]\n");
  440.  
  441.     /** get size if given **/
  442.     if (argc>2 && argv[1][0]=='-') {
  443.         if (sscanf(&argv[1][1], "%dx%d", &width, &height)!=2)
  444.             error("Illegal width/height format, use WxH, eg 32x24");
  445.         if (width > MAX_SPRITE_WIDTH || height > MAX_SPRITE_HEIGHT)
  446.             error("Sprite too large, max size %dx%d", 
  447.                     MAX_SPRITE_WIDTH, MAX_SPRITE_HEIGHT);
  448.         argc--;
  449.         argv++;
  450.     }
  451.     
  452.     gr_detect(GR_TYPE_SPR, &i, &j);
  453.     if (i == -1) {
  454.         puts("Unsupported graphics mode, sorry!");
  455.         exit(1);
  456.     }
  457.     gr_start(&i, &j);
  458.     if (mouse_initialize()==0)
  459.         error("No mouse driver found, cannot continue");
  460.     mouse_set_pointer_xy(gr_max_x/2, 3*gr_max_y/4);
  461.     
  462.     if (spred_edit(&sd, argc-1, argv+1) < 0)
  463.         exit(1);    /** some error, or quit **/
  464.  
  465.     exit(0);
  466. }
  467.