home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / C / CSOURCE.ZIP / BLEND.C next >
Encoding:
C/C++ Source or Header  |  1994-07-07  |  11.3 KB  |  440 lines
  1. /****************************************************************
  2. * FILE:    blend.c
  3. * DESC:    This program demonstrates how a color blend can be
  4. *        created by tweened morphing.
  5. * 
  6. * HISTORY:     7/05/1994
  7. * LAST CHANGED:  
  8. * 
  9. *    Copyright (c) 1994 by Scott Anderson
  10. *
  11. ****************************************************************/
  12.  
  13. /* ----------------------INCLUDES----------------------------- */
  14.  
  15. #include <conio.h>
  16. #include <stdio.h>
  17. #include <math.h>
  18. #include <graph.h>
  19.  
  20. /* ----------------------DEFINES------------------------------ */
  21.  
  22. #define YES            1
  23. #define NO            0
  24.  
  25. #define GRAY        8
  26.  
  27. #define XMIN        0
  28. #define XMAX        319
  29. #define XMID        ((XMAX + XMIN) / 2)
  30. #define YMIN        0
  31. #define YMAX        199
  32. #define YMID        ((YMAX + YMIN) / 2)
  33.  
  34. #define COLORS        256
  35. #define COLOR1        32
  36.  
  37. #define FACTOR        16    /* Bit rotate factor for fixed point */
  38. #define SHIFT_BITS     8    /* Rotate factor for color blend */
  39.  
  40. #define MAX_POINTS    32
  41. #define NTWEENS     32
  42.  
  43. #define ESC_KEY     27
  44.  
  45. #define PI            3.1415926535;
  46.  
  47. #define QUIT        (-1)
  48. #define SKIP        1
  49.  
  50. /* ----------------------TYPEDEFS/STRUCTS--------------------- */
  51.  
  52. typedef struct {    /* for the screen coordinates */
  53.     int x, y;                
  54. }
  55. POINT;
  56.  
  57. /* Delta is the difference array that gets added to Tween */
  58. typedef struct {
  59.     long x, y;                
  60. }
  61. DELTA;
  62.  
  63. typedef struct {    /* The high & low words in a long word */
  64.     int lo, hi;                
  65. }
  66. LO_HI;
  67.  
  68. /* A Fixed-point union:
  69.  * a long word broken up into low & high words */
  70. typedef union {
  71.     long lword;                /* The long word portion */
  72.     LO_HI word;    /* The high and low parts of this long word */
  73. }
  74. FIXED;
  75.  
  76. typedef struct {    /* A fixed-point coordinate pair */
  77.     FIXED x, y;                
  78. }
  79. TWEEN;
  80.  
  81. typedef struct {
  82.     /* red, green, and blue color components */
  83.     unsigned char r, g, b;    
  84. }
  85. COLOR;
  86.  
  87. /* ----------------------PROTOTYPES--------------------------- */
  88.  
  89. void    setGraphicsMode();
  90. void    setTextMode();
  91. int        blendPoly();
  92. void    calcTweens(int npoints, int ntweens);
  93. void    tweenObject(int npoints, int ntweens);
  94. void    getXY(POINT *point);
  95. void    getPoly(POINT array[], int npoints, int maxRad);
  96. void    drawObject(int npoints, int color);
  97. void    setSpread();
  98. void    setRandColor (int min, int max, COLOR *color);
  99. void    setPalColor(int index, int red, int green, int blue);
  100. int        quitCheck();
  101. int        keyCode(int key);
  102.  
  103. /* ----------------------GLOBAL DATA-------------------------- */
  104.  
  105. POINT    Source[MAX_POINTS];
  106. POINT    Target[MAX_POINTS];
  107. DELTA    Delta [MAX_POINTS];
  108. TWEEN    Tween [MAX_POINTS];
  109.  
  110. /*****************************************************************
  111. * FUNC: main (int argc, char *argv[])
  112. * 
  113. * DESC: Kickstart the random number generator, set the graphics
  114. *        mode and run blendPoly until Esc is pressed.
  115. *****************************************************************/
  116.  
  117. main (int argc, char *argv[])
  118. {
  119.     srand((unsigned int) time());
  120.     setGraphicsMode();
  121.     while (blendPoly());
  122.     setTextMode();
  123. }
  124.  
  125. /*****************************************************************
  126. * FUNC: int    blendPoly()
  127. * 
  128. * DESC: blend a random polygon into another one.
  129. *****************************************************************/
  130.  
  131. int
  132. blendPoly()
  133. {
  134.     int keyCode;
  135.     long start;
  136.     int npoints = random (3, MAX_POINTS);
  137.  
  138.     clearScreen(GRAY);
  139.     setSpread();
  140.     getPoly (Source, npoints, XMID);
  141.     getPoly (Target, npoints, XMID/4);
  142.  
  143.     calcTweens(npoints, NTWEENS);
  144.     tweenObject(npoints, NTWEENS);
  145.  
  146.     /* Wait a few seconds for a keystroke.
  147.      * Return 0 if ESC is pressed */
  148.     start = (long) time();
  149.     while ((long) time() - start < 3) {
  150.         keyCode = quitCheck();
  151.         if (keyCode == QUIT)
  152.             return 0;
  153.         else if (keyCode == SKIP)
  154.             return 1;
  155.     }
  156.     return 1;
  157. }
  158.  
  159. /*****************************************************************
  160. * FUNC: void    calcTweens(int npoints, int ntweens)
  161. * 
  162. * DESC: Calculate the Delta array from the Source and Target
  163. *****************************************************************/
  164.  
  165. void
  166. calcTweens(int npoints, int ntweens)
  167. {
  168.     int pt;
  169.     for (pt = 0; pt < npoints; pt++)
  170.     {    /* use fixed point long words to store the deltas */
  171.         Delta[pt].x = ((long)(Target[pt].x - Source[pt].x)
  172.                         << FACTOR) / ntweens;
  173.         Delta[pt].y = ((long)(Target[pt].y - Source[pt].y)
  174.                         << FACTOR) / ntweens;
  175.         Tween[pt].x.word.hi = Source[pt].x;    /* set high word */
  176.         Tween[pt].y.word.hi = Source[pt].y;
  177.         Tween[pt].x.word.lo = 0;            /* clear low word */
  178.         Tween[pt].y.word.lo = 0;
  179.     }
  180. }
  181.  
  182. /*****************************************************************
  183. * FUNC: void    tweenObject(int npoints, int ntweens)
  184. * 
  185. * DESC: Metamophose the Source polygon into the Target polygon
  186. *        by adding the Delta array.
  187. *****************************************************************/
  188.  
  189. void
  190. tweenObject(int npoints, int ntweens)
  191. {    /* Tween one object into another */
  192.     int tween, point;
  193.     int color = COLOR1;
  194.  
  195.      for (tween = 0; tween < ntweens; tween++)
  196.     {    /* Add deltas to tween array & draw new polygon */
  197.         for (point = 0; point < npoints; point++)
  198.         {    /* Add delta to tween the line */
  199.             Tween[point].x.lword += Delta[point].x;
  200.             Tween[point].y.lword += Delta[point].y;
  201.         }
  202.         drawObject(npoints, color++);
  203.     }    
  204. }
  205.  
  206. /*****************************************************************
  207. * FUNC: void    drawObject(int npoints, int color)
  208. * 
  209. * DESC: Copy the points into an xycoord struct & draw the poly.
  210. *****************************************************************/
  211.  
  212. void
  213. drawObject(int npoints, int color)
  214. {
  215.     struct _xycoord poly[MAX_POINTS];
  216.     int point;
  217.     
  218.     int fillOK = NO;
  219.     int oldY = Tween[0].y.word.hi;
  220.  
  221.     for (point = 0; point < npoints; point++)
  222.     {    /* get the coords from the hi word of the Tween array */
  223.         poly[point].xcoord = Tween[point].x.word.hi;
  224.         poly[point].ycoord = Tween[point].y.word.hi;
  225.  
  226.         /* The following code is to fix a fatal bug in the
  227.          * Microsoft polygon fill routine that occurs when all
  228.          * of the Y-values are the same (a horizontal line).
  229.          * There is also a bug when the bottom line of the poly
  230.          * is horizontal, but at least that bug doesn't crash
  231.          * the machine...
  232.          */
  233.         if (poly[point].ycoord != oldY)
  234.             fillOK = YES;    /* y is different, so fill poly */
  235.     }
  236.     _setcolor(color);
  237.     if (fillOK)                    /* don't crash the system! */
  238.         _polygon(_GFILLINTERIOR, poly, npoints);
  239. }
  240.  
  241. /*****************************************************************
  242. * FUNC: void    getPoly(POINT array[], int npoints, int maxRad)
  243. * 
  244. * DESC: Create a random polygon and put it in array
  245. *****************************************************************/
  246.  
  247. void
  248. getPoly(POINT array[], int npoints, int maxRad)
  249. {    /* Generate a random set of points */
  250.     int point;
  251.     int rad, phase, jagFactor;
  252.     float theta;
  253.     float twoPi = 2 * PI;
  254.  
  255.     jagFactor = random(1, 4);
  256.     phase = twoPi / random(6, 20);
  257.     for (point = 0, theta = 0; point < npoints;
  258.             point++, theta += twoPi / npoints) {
  259.         rad = random(maxRad / jagFactor, maxRad);
  260.         array[point].x = XMID + rad * cos(theta + phase);
  261.         array[point].y = YMID + rad * sin(theta + phase);
  262.     }
  263. }
  264.  
  265. /*****************************************************************
  266. * FUNC: void    setSpread()
  267. * 
  268. * DESC: Create a random color spread
  269. *****************************************************************/
  270.  
  271. void
  272. setSpread()
  273. {
  274.     int    index;
  275.     int    rotRed, rotGreen, rotBlue;
  276.     int    dRed,   dGreen,   dBlue;
  277.     COLOR colorA, colorB;
  278.  
  279.     if (rand() & 1) {
  280.         setRandColor ( 0, 16, &colorA);
  281.         setRandColor (22, 32, &colorB);
  282.     }
  283.     else {
  284.         setRandColor (22, 32, &colorA);
  285.         setRandColor ( 0, 16, &colorB);
  286.     }
  287.  
  288.     rotRed   = (int) colorA.r << SHIFT_BITS;
  289.     rotGreen = (int) colorA.g << SHIFT_BITS;
  290.     rotBlue  = (int) colorA.b << SHIFT_BITS;
  291.  
  292.     dRed   =  ((int)(colorB.r - colorA.r) << SHIFT_BITS)
  293.                     / NTWEENS;
  294.     dGreen =  ((int)(colorB.g - colorA.g) << SHIFT_BITS)
  295.                     / NTWEENS;
  296.     dBlue  =  ((int)(colorB.b - colorA.b) << SHIFT_BITS)
  297.                     / NTWEENS;
  298.  
  299.     for (index = 0; index < NTWEENS; index++) {  
  300.         setPalColor(index + COLOR1,
  301.                     rotRed   >> SHIFT_BITS,
  302.                     rotGreen >> SHIFT_BITS,
  303.                     rotBlue  >> SHIFT_BITS);
  304.  
  305.         rotRed        += dRed;
  306.         rotGreen    += dGreen;
  307.         rotBlue        += dBlue;
  308.     }
  309. }
  310.  
  311. /*****************************************************************
  312. * FUNC: void setRandColor  (int min, int max, COLOR *color)
  313. * 
  314. * DESC: Create a pointer to a random color with RGB components
  315. *            between the min and max component value.
  316. *****************************************************************/
  317.  
  318. void
  319. setRandColor (int min, int max, COLOR *color)
  320. {
  321.     color->r = min + random(0, max - min);
  322.     color->g = min + random(0, max - min);
  323.     color->b = min + random(0, max - min);
  324. }
  325.  
  326. /*****************************************************************
  327. * FUNC: int    random(int low, int high)
  328. * 
  329. * DESC: Return a random number between the low and high values
  330. *****************************************************************/
  331.  
  332. int
  333. random (int low, int high)
  334. {    /* get a random number between low and high, inclusively */
  335.     if (high < low) return (low);    /* don't divide by zero */
  336.     return (low + (rand() % (high - low + 1)));
  337. }
  338.  
  339. /*****************************************************************
  340. * FUNC: int    quitCheck()
  341. * 
  342. * DESC: Check keyboard. If there is no key waiting, return 0,
  343. *        for OK. If a number from 1-9 is typed, change the wait
  344. *        between frames. Otherwise, the user wants to quit,
  345. *        so return 1.
  346. *****************************************************************/
  347.  
  348. int
  349. quitCheck()
  350. {
  351.     int    key;
  352.     static int spaceWait = NO;
  353.  
  354.     if (spaceWait) {
  355.         key = getch();
  356.         if (key != ' ')
  357.             spaceWait = NO;
  358.         return keyCode(key);
  359.     }
  360.     else if (_kbhit()) {
  361.         key = _getch();
  362.         if (key == ' ') {
  363.             /* turn on space bar stepping */
  364.             spaceWait = YES;
  365.             /* pause for space key */
  366.             key = _getch();
  367.         }
  368.         return keyCode(key);
  369.     }
  370.     return 0;
  371. }
  372.  
  373. /*****************************************************************
  374. * FUNC: int    keyCode(int key)
  375. * 
  376. * DESC: Parse the key and return a quit or skip code.
  377. *****************************************************************/
  378.  
  379. int
  380. keyCode(int key)
  381. {
  382.     if (key == ESC_KEY || key == 'q' || key == 'Q')
  383.         return QUIT;    /* a quit key */
  384.     else return SKIP;    /* otherwise, skip */
  385. }
  386.  
  387. /*****************************************************************
  388. * FUNC: void    setGraphicsMode()
  389. * 
  390. * DESC: Set up the graphics screen
  391. *****************************************************************/
  392.  
  393. void
  394. setGraphicsMode()
  395. {
  396.     _setvideomode(_MRES256COLOR);
  397. }
  398.  
  399. /*****************************************************************
  400. * FUNC: void    setTextMode()
  401. * 
  402. * DESC: Set the screen to the startup text mode
  403. *****************************************************************/
  404.  
  405. void
  406. setTextMode()
  407. {
  408.     _setvideomode(_DEFAULTMODE);
  409. }
  410.  
  411. /*****************************************************************
  412. * FUNC: int    clearScreen(int color)
  413. * 
  414. * DESC: Clear screen to the given color
  415. *****************************************************************/
  416.  
  417. int
  418. clearScreen(int color)
  419. {
  420.     _setcolor(color);
  421.     _rectangle(_GFILLINTERIOR, XMIN, YMIN, XMAX, YMAX);
  422. }
  423.  
  424. /*****************************************************************
  425. * FUNC: void setPalColor(int index, int red, int green, int blue)
  426. * 
  427. * DESC:set the palette register to the color components
  428. *****************************************************************/
  429.  
  430. void
  431. setPalColor(int index, int red, int green, int blue)
  432. {
  433.     _outp (0x3c7, index-1);
  434.     _outp (0x3c9, red);
  435.     _outp (0x3c9, green);
  436.     _outp (0x3c9, blue);
  437. }
  438.  
  439.  
  440.