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