home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / GRAPHICS / MISC / STK100.ZIP / STKSRC.COM / SPR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-20  |  15.3 KB  |  464 lines
  1. /**********************************************************************
  2. * spr.c
  3. *
  4. * The sprite support system main functions
  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 <stdlib.h>
  21.  
  22. #include <alloc.h>      /* farmalloc(), farfree() */
  23. #include <dos.h>        /* delay() */
  24. #include <graphics.h>   /* setactivepage(), setvisualpage(), mode defines */
  25. #include <mem.h>        /* memcpy(), movedata() */
  26. #include <time.h>       /* clock(), clock_t */
  27.  
  28. #include "sprP.h"
  29. #include "spr.h"
  30. #include "spr_low.h"
  31. #include "spr_misc.h"
  32.  
  33. /** display lists for each display page **/
  34. SPRITE spr_sprites[2] = { NULL, NULL };
  35.  
  36. /** the sprites to be destroyed after next_pass **/
  37. static SPRITE destroy_list = { NULL };
  38.  
  39. /** the current drawing page **/
  40. WORD spr_drawingpage = 0;
  41.  
  42. /**********************************************************************
  43. * The delay after setvisualpage() before removing old objects. 
  44. * Time is given in milliseconds. Hercules cards do not need this,
  45. * but many EGA/VGA cards do need some milliseconds to switch pages.
  46. **********************************************************************/
  47. int spr_pass_delay = 10;
  48.  
  49. /**********************************************************************
  50. * Called from low level funtions if not sprite system initialized, 
  51. * or if initialization fails.
  52. **********************************************************************/
  53. void static fatal_error()
  54. {
  55.     closegraph();
  56.     puts("FATAL: Sprite system initialization error.");
  57.     exit(255);
  58. }
  59.  
  60.  
  61. /** hardware dependent putter **/
  62. void static (*spr_low_putter)
  63.                     (BYTE far *shape, BYTE far *dest, BYTE far *save, 
  64.                      WORD w, WORD h) = fatal_error;
  65.                    
  66. /** hardware dependent eraser  **/
  67. void static (*spr_low_eraser)(BYTE far *dest, BYTE far *save, 
  68.                        WORD w, WORD h) = fatal_error;    
  69.  
  70. /** hardware dependent address calculator (TCC gives warning here) **/
  71. BYTE static far *(*spr_low_addr)(WORD x, WORD y, BYTE page) = fatal_error; 
  72.  
  73.  
  74. /**********************************************************************
  75. * Initialize the sprite system to the given display hardware.
  76. * Supported graphicsdrivers: EGAMONO and HERCMONO
  77. * The visual page is set to 0.
  78. * NOTE: This function must be called before any other sprite funtions
  79. *       and the graphics mode must have been set before this call.
  80. * 
  81. * graphicsdriver  The BGI identifier for the graphics driver used.
  82. **********************************************************************/
  83. void spr_initialize(int graphicsdriver)
  84. {
  85.     switch (graphicsdriver) {
  86.         case HERCMONO:
  87.             spr_low_putter = spr_low_herc_put;
  88.             spr_low_eraser = spr_low_herc_erase;
  89.             spr_low_addr   = spr_low_herc_addr;
  90.             spr_pass_delay = 1; /** hercules cards do not need this **/
  91.             break;
  92.             
  93.         case EGAMONO:
  94.             spr_low_putter = spr_low_ega_mono_put;
  95.             spr_low_eraser = spr_low_ega_mono_erase;
  96.             spr_low_addr   = spr_low_ega_mono_addr;
  97.             break;
  98.             
  99.         default:
  100.             fatal_error();  /**  (TCC gives warning here) **/
  101.     }
  102.  
  103.     setvisualpage(spr_drawingpage);
  104. }
  105.  
  106.  
  107.  
  108. /**********************************************************************
  109. * Create a sprite.
  110. *
  111. * w,h   Width (must be < 8*255) and height (<256) of sprite in pixels
  112. * pic   The picture bitmap for the sprite
  113. * mask  The mask bitmap for the sprite
  114. * res   The number of steps wanted per 8 bit interval in horizontal
  115. *       direction (1,2,4,8). For example, the value 8 gives one
  116. *       pixel resolution in X-direction.
  117. * ID    The user supplied ID for the sprite (not obligatory)
  118. *
  119. * Return: the newly created sprite or NULL if parameter error
  120. *           or out-of-memory
  121. **********************************************************************/
  122. SPRITE spr_create(WORD w, WORD h, 
  123.                   BITMAP shape, BITMAP mask, 
  124.                   BYTE res, WORD ID)
  125. {
  126.     SPRITE spr;
  127.     WORD size;
  128.     
  129.     if (w<8 || h<1 || w >= 8*255 || h > 255 || shape==NULL || mask==NULL)
  130.         return NULL;
  131.  
  132.     if (res!=1 && res!=2 && res!=4 && res!=8)
  133.         return NULL;
  134.     
  135.     spr = (SPRITE)malloc(sizeof(struct _sprite));
  136.     if (spr==NULL)
  137.         return NULL;
  138.  
  139.     if (w&7)
  140.         spr->w = (w>>3) + 1;    /* not exact byte boundary, round up */
  141.     else
  142.         spr->w = w>>3;
  143.  
  144.     if (res>1)      /** make space for right shifts **/
  145.         spr->w++;
  146.     
  147.     spr->wp = w;    
  148.     spr->hp = h;    
  149.     spr->res = res;
  150.     spr->flags = FLAG_NONE;
  151.     spr->id = ID;
  152.     spr->x = spr->y = (WORD)-1;     /* Place it out of screen initially */
  153.  
  154.     size = spr->w * spr->hp;         /* size of one bitmap */
  155.     spr->size = size * 2;           /* shape + mask size */
  156.     
  157.     /** malloc space for usage count, bitmaps + save buffer for old images **/
  158.     spr->data = (FARMAP)farmalloc(spr->size*(long)res + size*2L);
  159.     if (spr->data==NULL) {
  160.         free(spr);
  161.         return NULL;
  162.     }
  163.  
  164.     /** create shifted/combined shape/mask maps **/
  165.     spr_misc_create_data(spr, shape, mask);
  166.     
  167.     /** set save buffer address for both display pages **/
  168.     spr->saved[0] = spr->data + (spr->size * res);
  169.     spr->saved[1] = spr->data + (spr->size * res + size);
  170.     
  171.     spr->next[0] = spr->next[1] = NULL;
  172.     spr->addr[0] = spr->addr[1] = NULL;
  173.  
  174.     spr->share = NULL;
  175.     spr->share_index = 0;
  176.     
  177.     return spr;
  178. }
  179.  
  180. /**********************************************************************
  181. * Create a shared version of the given sprite. This allows
  182. * n spr_copies which all share the shape data thus saving
  183. * quite much memory.
  184. *
  185. * spr   The sprite to share
  186. * n     The maximum number of shared copies
  187. *
  188. * Return: New SPRITE or NULL if error (out of memory, spr==NULL, etc)
  189. **********************************************************************/
  190. SPRITE spr_share(SPRITE spr, BYTE n)
  191. {
  192.     WORD size, i;
  193.     
  194.     if (spr==NULL)
  195.         return NULL;
  196.     
  197.     size = spr->w * spr->hp;         /* size of one bitmap */
  198.     n++;
  199.     
  200.     /** Reallocate space for shapes, save space for copies and share index **/
  201.     spr->data = (FARMAP)farrealloc(spr->data,
  202.                                    spr->size*spr->res + n*size*2L + n);
  203.     
  204.     /** Reset old save buffer address for both display pages **/
  205.     /** (Realloc might move the block) **/
  206.     spr->saved[0] = spr->data + (spr->size * spr->res);
  207.     spr->saved[1] = spr->data + (spr->size * spr->res + size);
  208.     
  209.     /** Set share index pointer and reset its contents **/
  210.     spr->share = spr->data + (spr->size*spr->res + n*size*2L);
  211.     spr->share_index = 0;
  212.     spr->max_share = n-1;
  213.     spr->share[spr->share_index] = 1;
  214.     for (i=1; i<spr->max_share; i++)
  215.         spr->share[i] = 0;
  216.     
  217.     return spr;
  218. }
  219.  
  220.  
  221. /**********************************************************************
  222. * Return a copy of the given sprite.
  223. *
  224. * spr   The sprite to copy
  225. * id    The ID for the new sprite
  226. *
  227. * Return: New SPRITE of NULL if error (out of memory, spr==NULL, etc)
  228. **********************************************************************/
  229. SPRITE spr_copy(SPRITE spr_old, WORD id)
  230. {
  231.     SPRITE spr;
  232.     WORD size, i;
  233.  
  234.     if (spr_old==NULL)
  235.         return NULL;
  236.     
  237.     spr = (SPRITE)malloc(sizeof(struct _sprite));
  238.     if (spr==NULL)
  239.         return NULL;
  240.     memcpy(spr, spr_old, sizeof(struct _sprite));
  241.  
  242.     spr->id = id;
  243.     size = spr->w * spr->hp;         /* size of one bitmap */
  244.  
  245.     if (spr->share!=NULL) { /** we have a shared sprite **/
  246.         for (i=0; i<spr->max_share; i++)
  247.             if (spr->share[i]==0)
  248.                 break;
  249.         if (i==spr->max_share) {    /** no free slots **/
  250.             free(spr);
  251.             return NULL;
  252.         }
  253.         spr->saved[0] = spr->data + (spr->size * spr->res + (size*2)*i);
  254.         spr->saved[1] = spr->data + (spr->size * spr->res + (size*2)*i+size);
  255.         spr->share[i] = 1;
  256.         spr->share_index = i;
  257.     }
  258.     else {  /** not shared, must make a full copy **/
  259.         /** space for usage count, bitmaps + save buffer for old images **/
  260.         spr->data = (FARMAP)farmalloc(spr->size*spr->res + size*2L);
  261.         if (spr->data==NULL) {
  262.             free(spr);
  263.             return NULL;
  264.         }
  265.  
  266.         movedata(FP_SEG(spr_old->data), FP_OFF(spr_old->data),
  267.                  FP_SEG(spr->data), FP_OFF(spr->data),
  268.                  spr->size*spr->res);
  269.  
  270.         /** set save buffer address for both display pages **/
  271.         spr->saved[0] = spr->data + (spr->size * spr->res);
  272.         spr->saved[1] = spr->data + (spr->size * spr->res + size);
  273.     }
  274.  
  275.     return spr;
  276. }
  277.  
  278. /**********************************************************************
  279. * Put the sprite into the given position into the display list.
  280. * NOTE: the call has no effect on screen until a call to 
  281. *       spr_next_pass() is made.
  282. *
  283. * spr   The sprite to put
  284. * x     The X coordinate
  285. * y     The Y coordinate
  286. **********************************************************************/
  287. void spr_put(SPRITE spr, WORD x, WORD y)
  288. {
  289.     /** add sprite to the display list **/
  290.     spr->next[spr_drawingpage] = spr_sprites[spr_drawingpage];
  291.     spr_sprites[spr_drawingpage] = spr;
  292.     
  293.     /** save coordinates for collision checking & SHAPE_OFS macro **/
  294.     spr->x = x;
  295.     spr->y = y;
  296.     
  297.     spr->addr[spr_drawingpage] = spr_low_addr(x,y,spr_drawingpage);
  298. }
  299.  
  300. /**********************************************************************
  301. * Remove the sprite from the display list
  302. * NOTE: the call has no effect on screen until a call to 
  303. *       spr_next_pass() is made.
  304. *
  305. * spr   The sprite to hide
  306. **********************************************************************/
  307. void spr_hide(SPRITE spr)
  308. {
  309.     spr_misc_delete(spr, spr_drawingpage);
  310. }
  311.  
  312. /**********************************************************************
  313. * Delete the given sprite and release associated memory buffers.
  314. * Also delete it from the display lists. (Actually the sprite is
  315. * only hidden and moved into the deletion list, the memory is freed
  316. * after the next_pass().)
  317. *
  318. * spr   The sprite to delete
  319. **********************************************************************/
  320. void spr_delete(SPRITE spr)
  321. {
  322.     spr_hide(spr);
  323.     spr->next[spr_drawingpage] = destroy_list;
  324.     destroy_list = spr;    
  325. }
  326.  
  327. /**********************************************************************
  328. * Display all sprites in the chain in reversed order.
  329. * NOTE: this is recursive, so it needs 4-8 bytes (depending on memory
  330. * model) of stack space for each sprite.
  331. **********************************************************************/
  332. void static show_all_reversed(SPRITE s)
  333. {
  334.     if (s==NULL)
  335.         return;
  336.     
  337.     /** First descent recursively to the end of list **/
  338.     if (s->next[spr_drawingpage]!=NULL)
  339.         show_all_reversed(s->next[spr_drawingpage]);
  340.  
  341.     spr_low_putter(s->data+SHAPE_OFS(s), 
  342.                    s->addr[spr_drawingpage], s->saved[spr_drawingpage],
  343.                    s->w, s->hp);
  344. }
  345.  
  346. /**********************************************************************
  347. * This function actually shows the sprites.
  348. * The following functions are performed (the order is important):
  349. * - put all sprite images into the hidden page (in reverse order).
  350. * - set hidden page to visual page (delay a moment for EGA cards).
  351. * - delete the old sprite images from the (now hidden) page.
  352. * - now it is safe to actually free the spr_deleted sprites.
  353. *
  354. * Return: The current visual page.
  355. **********************************************************************/
  356. WORD spr_next_pass(void)
  357. {
  358.     SPRITE s;
  359.     int i;
  360.  
  361.     /** Display all sprites at once in reverse order **/
  362.     show_all_reversed(spr_sprites[spr_drawingpage]);
  363.     
  364.     setvisualpage(spr_drawingpage); /** show 'em **/
  365.     
  366.     delay(spr_pass_delay);          /** EGA/VGA cards are SLOW! **/
  367.     
  368.     /** Then delete old ones **/
  369.     spr_drawingpage ^= 1;
  370.     s = spr_sprites[spr_drawingpage];
  371.     while (s!=NULL) {
  372.         spr_low_eraser(s->addr[spr_drawingpage], s->saved[spr_drawingpage],
  373.                        s->w,s->hp);
  374.         s = s->next[spr_drawingpage];
  375.     }
  376.     spr_sprites[spr_drawingpage] = NULL;
  377.     
  378.     /** Destroy the sprites which have been spr_deleted **/
  379.     s = destroy_list;
  380.     while (s!=NULL) {
  381.         if (s->share!=NULL) { /** if shared must check for usage **/
  382.             s->share[s->share_index] = 0;
  383.             for (i=0; i<s->max_share; i++)
  384.                 if (s->share[i])
  385.                     break;
  386.             if (i==s->max_share)
  387.                 farfree(s->data);
  388.         }
  389.         else
  390.             farfree(s->data);
  391.         
  392.         free(s);
  393.         s = s->next[spr_drawingpage^1];
  394.     }
  395.     destroy_list = NULL;
  396.         
  397.     return spr_drawingpage^1;
  398. }
  399.  
  400. /**********************************************************************
  401. * This function tries to regulate the frame speed by delaying if
  402. * we are doing more frames per second than we should. The target 
  403. * speed is 1 frame per one clock tick (about 18 frames per second).
  404. * (This is about the highest reasonable rate for 15-20 32x24 pixel
  405. * sprites on a Hercules screen with a 10 MHz 286.)
  406. **********************************************************************/
  407. void spr_regulate_speed(void)
  408. {
  409.     static int d=0;
  410.     static int j=0;
  411.     static clock_t old_clock=0;
  412.     int i;
  413.     
  414.     delay(d);
  415.     if ((j++ & 7)==7) {
  416.         if ((i=(int)(clock()-old_clock)) < 8)
  417.             d += 8-i;   /** running too fast (more than frame per tick) **/
  418.         else 
  419.             if (d>0)    /** running too slow (less than frame per tick) **/
  420.                 d--;
  421.         old_clock = clock();
  422.     }    
  423. }
  424.  
  425. /**********************************************************************
  426. * Return the user supplied identifier of the sprite
  427. **********************************************************************/
  428. WORD spr_get_id(SPRITE spr)
  429. {
  430.     return spr->id;
  431. }
  432.  
  433. /**********************************************************************
  434. * Return the X coordinate of the sprite
  435. **********************************************************************/
  436. WORD spr_get_x(SPRITE spr)
  437. {
  438.     return spr->x;
  439. }
  440.  
  441. /**********************************************************************
  442. * Return the Y coordinate of the sprite
  443. **********************************************************************/
  444. WORD spr_get_y(SPRITE spr)
  445. {
  446.     return spr->y;
  447. }
  448.  
  449. /**********************************************************************
  450. * Return the width of the sprite
  451. **********************************************************************/
  452. WORD spr_get_width(SPRITE spr)
  453. {
  454.     return spr->w*8;
  455. }
  456.  
  457. /**********************************************************************
  458. * Return the height of the sprite
  459. **********************************************************************/
  460. WORD spr_get_height(SPRITE spr)
  461. {
  462.     return spr->hp;
  463. }
  464.