home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / viscobv6.zip / vac22os2 / ibmcobol / samples / toolkit / mm / beehive / animate.c next >
Text File  |  1996-11-19  |  9KB  |  287 lines
  1. /***************************************************************************
  2. *
  3. * File name        : ANIMATE.C
  4. *
  5. * Description      : This module contains the procedure that will maintain
  6. *                    the sprites and update the scene buffer. Also, the
  7. *                    procedure that provides for the "normal sprit" algorithm
  8. *                    is also here
  9. *
  10. *
  11. * Copyright        : COPYRIGHT IBM CORPORATION, 1991, 1992, 1993, 1994, 1995
  12. *
  13. *        DISCLAIMER OF WARRANTIES.  The following [enclosed] code is
  14. *        sample code created by IBM Corporation. This sample code is not
  15. *        part of any standard or IBM product and is provided to you solely
  16. *        for  the purpose of assisting you in the development of your
  17. *        applications.  The code is provided "AS IS", without
  18. *        warranty of any kind.  IBM shall not be liable for any damages
  19. *        arising out of your use of the sample code, even if they have been
  20. *        advised of the possibility of such damages.
  21. *
  22. ****************************************************************************/
  23.  
  24.  
  25. #define INCL_DOS
  26.  
  27. #include <os2.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <stdio.h>
  31. #include <dive.h>
  32. #include "beehive.h"
  33.  
  34.  
  35. extern BMPDATA bmpScene,
  36.                bmpImage1,
  37.                bmpImage1b,
  38.                bmpImage2,
  39.                bmpImage2b,
  40.                bmpBackGround;
  41.  
  42. extern SPRITEDATA FirstSprite;
  43.  
  44. extern BOOL    fEndThread;
  45. extern HDIVE   hDive;
  46. extern HWND    hwndFrame;
  47. extern BOOL    fVrnDisabled;
  48. extern BOOL    fUseCompiledBlit;
  49. extern HMTX    hmtx;
  50.  
  51.  
  52. //************************************************************************
  53. //
  54. // Name        : BlitSprite
  55. //
  56. // Description : This function is provided to demonstrate the
  57. //               diference between conventional sprite alogrithms
  58. //               and a compiled sprite. When called, this routine
  59. //               will copy the passed sprite to an arbitrary location
  60. //               in a destination buffer. The user can select which
  61. //               routine the application will use from the options
  62. //               menu.
  63. //
  64. //************************************************************************
  65.  
  66. VOID  BlitSprite( PBMPDATA pbmpSprite,       // Pointer to sprite structure
  67.                   PBMPDATA pbmpScene,        // Pointer to target structure.
  68.                   ULONG    ulPositionX,      // Sprite X position in target
  69.                   ULONG    ulPositionY,      // Sprite Y position in target
  70.                   BYTE     bTransparentColor )
  71. {
  72.    PBYTE    pbTarget,
  73.             pbSource;
  74.  
  75.    ULONG    ulIndex1,
  76.             ulIndex2;
  77.  
  78.    // Copy the source pointer.
  79.    //
  80.    pbSource = pbmpSprite->pbBuffer;
  81.  
  82.    // Copy the destination pointer and adjust for the position of the
  83.    // sprite.
  84.    //
  85.    pbTarget = pbmpScene->pbBuffer +
  86.               ulPositionY * pbmpScene->ulWidth +  ulPositionX;
  87.  
  88.    // Process each scan line in the sprite.
  89.    //
  90.    for( ulIndex1 = 0; ulIndex1 < pbmpSprite->ulHeight; ulIndex1++ )
  91.    {
  92.       // Traverse one line of the sprite while checking each pixel
  93.       // for transparency before copying.
  94.       //
  95.       for( ulIndex2 = 0; ulIndex2 < pbmpSprite->ulWidth; ulIndex2++ )
  96.       {
  97.          // Check if this pixel is a transparent color. If not, then copy the
  98.          // pixel to the target and update the pointers.
  99.          //
  100.          if( *pbSource != bTransparentColor )
  101.             *pbTarget++ = *pbSource++;
  102.          else
  103.          {
  104.             // Here if the pixel was transparent so we don't copy the pixel
  105.             // and we just increment the buffer pointers.
  106.             //
  107.             *pbTarget++;
  108.             *pbSource++;
  109.          }
  110.       }  // end for loop
  111.  
  112.       // Adjust the target buffer pointer for the next scan line
  113.       //
  114.       pbTarget += pbmpScene->ulWidth - pbmpSprite->ulWidth;
  115.  
  116.    } // end for loop
  117. }
  118.  
  119.  
  120.  
  121.  
  122. //************************************************************************
  123. //
  124. // Name        : Animation
  125. //
  126. // Description : This procedure is spawned in a separate thread and
  127. //               is responsible for updating the scene buffer.
  128. //
  129. // Returns     : none
  130. //
  131. //************************************************************************
  132.  
  133. VOID APIENTRY Animation ( void )
  134. {
  135.    CHAR     szFrameRate[256];
  136.    PSPRITEDATA pSprite;
  137.    ULONG    ulFramesToTime = 16,
  138.             rc,
  139.             ulNumFrames = 0,
  140.             ulPostCount,
  141.             ulTime0 = 0,
  142.             ulTime1 = 0,
  143.             ulSpriteCount;
  144.  
  145.  
  146.    while( !fEndThread )
  147.    {
  148.       //Clear the scene buffer
  149.       //
  150.       memcpy( bmpScene.pbBuffer,
  151.               bmpBackGround.pbBuffer,
  152.               bmpScene.ulWidth * bmpScene.ulHeight );
  153.  
  154.       // Get the first sprite in the sprite list
  155.       //
  156.       pSprite = &FirstSprite;
  157.  
  158.       // Zero the sprite counter
  159.       //
  160.       ulSpriteCount = 0;
  161.  
  162.       // Add each sprite from the list to the scene buffer
  163.       //
  164.       do
  165.       {
  166.          ulSpriteCount++;
  167.  
  168.          // The fUseCompiledBlit flag determins what blit routine we will
  169.          // use
  170.          if( fUseCompiledBlit == TRUE )
  171.          {
  172.             // Add sprite to image buffer using the compiled blitter
  173.             //
  174.             pSprite->pbmp->pfnBlit( pSprite->pbmp->pbBuffer,
  175.                                     bmpScene.pbBuffer,
  176.                                     pSprite->ulPositionX,
  177.                                     pSprite->ulPositionY );
  178.          }
  179.          else
  180.          {
  181.             // Add the sprite to the image buffer using the normal blitter.
  182.             //
  183.             BlitSprite( pSprite->pbmp,
  184.                         &bmpScene,
  185.                         pSprite->ulPositionX,
  186.                         pSprite->ulPositionY,
  187.                         0 );
  188.          }
  189.  
  190.          // Upate the sprite image
  191.          //
  192.          if( pSprite->lDeltaX > 0 )
  193.          {
  194.             if( pSprite->ulState == 1 )
  195.             {
  196.                pSprite->ulState = 2;
  197.                pSprite->pbmp = &bmpImage1b;
  198.             }
  199.             else
  200.             {
  201.                pSprite->ulState = 1;
  202.                pSprite->pbmp = &bmpImage1;
  203.             }
  204.          }
  205.          else
  206.          {
  207.             if( pSprite->ulState == 1 )
  208.             {
  209.                pSprite->ulState = 2;
  210.                pSprite->pbmp = &bmpImage2b;
  211.             }
  212.             else
  213.             {
  214.                pSprite->ulState = 1;
  215.                pSprite->pbmp = &bmpImage2;
  216.             }
  217.          }
  218.  
  219.          // Update the position of this sprite
  220.          //
  221.          pSprite->ulPositionX += pSprite->lDeltaX;
  222.          pSprite->ulPositionY += pSprite->lDeltaY;
  223.  
  224.          // Check for collision with the walls
  225.          //
  226.          if( pSprite->ulPositionX >= ( bmpScene.ulWidth - bmpImage1.ulWidth ) )
  227.          {
  228.             pSprite->lDeltaX *= -1;
  229.             pSprite->ulPositionX += pSprite->lDeltaX;
  230.  
  231.             // Set the correct sprite frame
  232.             //
  233.             if( pSprite->lDeltaX < 0 )
  234.                pSprite->pbmp = &bmpImage2;
  235.             else
  236.                pSprite->pbmp = &bmpImage1;
  237.          }
  238.  
  239.          if( pSprite->ulPositionY >= ( bmpScene.ulHeight - bmpImage1.ulHeight ) )
  240.          {
  241.             pSprite->lDeltaY *= -1;
  242.             pSprite->ulPositionY += pSprite->lDeltaY;
  243.          }
  244.  
  245.          pSprite = pSprite->pNextSprite;
  246.  
  247.       } while( pSprite != NULL );
  248.  
  249.  
  250.       // Make sure that the buffers are free.
  251.       //
  252.       DosRequestMutexSem( hmtx, SEM_INDEFINITE_WAIT );
  253.  
  254.       // Blit the scene to the screen
  255.       //
  256.       if( !fVrnDisabled )
  257.          DiveBlitImage( hDive, bmpScene.ulImage, DIVE_BUFFER_SCREEN );
  258.  
  259.       if( !ulNumFrames++ )
  260.          DosQuerySysInfo ( QSV_MS_COUNT, QSV_MS_COUNT, &ulTime0, 4L );
  261.  
  262.       // Update the title bar with the appropriate frame rate and sprite
  263.       // count.
  264.       //
  265.       if( ulNumFrames == ulFramesToTime )
  266.       {
  267.          DosQuerySysInfo ( QSV_MS_COUNT, QSV_MS_COUNT, &ulTime1, 4L );
  268.          ulTime1 -= ulTime0;
  269.  
  270.          sprintf( szFrameRate,
  271.                   "F.P.S. = %d, Sprite Count = %d ",
  272.                   ulFramesToTime * 1000 / ulTime1,
  273.                   ulSpriteCount );
  274.          ulNumFrames = 0;
  275.          WinPostMsg( hwndFrame, WM_COMMAND, (PVOID)ID_NEWTEXT, szFrameRate );
  276.       }
  277.  
  278.       DosReleaseMutexSem( hmtx );
  279.  
  280.       // This call will create a small hit on the frame rate but will make
  281.       // the application much more friendly to other applications.
  282.       //
  283.       DosSleep( 0 );
  284.    }
  285.  
  286. }
  287.