home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / FORTH / FRASRC11.ZIP / ROTATE.C < prev    next >
C/C++ Source or Header  |  1989-09-26  |  12KB  |  405 lines
  1. /*
  2.     rotate.c - Routines that manipulate the Video DAC on VGA Adapters
  3. */
  4.  
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8.  
  9. #include "fractint.h"
  10.  
  11. extern char temp1[];
  12.  
  13. extern    int    colors;                /* maximum colors available */
  14.  
  15. extern unsigned char dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
  16. extern int    daclearn, daccount;    /* used by the color-cyclers */
  17. extern int    reallyega;        /* == 0 if it's really an EGA */
  18. extern int    extraseg;        /* used by Save-to-GIF routines */
  19.  
  20. static int paused;                /* rotate-is-paused flag */
  21.  
  22.  
  23. static unsigned char Red[3]    = {63, 0, 0};    /* for shifted-Fkeys */
  24. static unsigned char Green[3]  = { 0,63, 0};
  25. static unsigned char Blue[3]   = { 0, 0,63};
  26. static unsigned char Black[3]  = { 0, 0, 0};
  27. static unsigned char White[3]  = {63,63,63};
  28. static unsigned char Yellow[3] = {63,63, 0};
  29. static unsigned char Brown[3]  = {31,31, 0};
  30.  
  31. rotate(direction)            /* rotate-the-palette routine    */
  32. int direction;
  33. {
  34. int  kbdchar, more, last, next, maxreg;
  35. int fkey, length, step, fstep, istep, jstep, oldstep;
  36. int incr, random, fromred, fromblue, fromgreen, tored, toblue, togreen;
  37. int i, changecolor, changedirection;
  38. int oldhelpmode;
  39.  
  40. static int fsteps[] = {2,4,8,12,16,24,32,40,54,100}; /* (for Fkeys) */
  41.  
  42. FILE *dacfile;
  43.  
  44. if (dacbox[0][0] == 255 ||         /* ??? no DAC to rotate!    */
  45.     colors < 16) {            /* strange things happen in 2x modes */
  46.         buzzer(2);
  47.         return;
  48.         }
  49. oldhelpmode = helpmode;            /* save the old help mode */
  50. helpmode = HELPCYCLING;            /* new help mode */
  51.  
  52. paused = 0;                /* not paused            */
  53. length = 0;                /* no random coloring        */
  54. step = 1;                /* single-step            */
  55. fkey = 0;                /* no random coloring        */
  56. changecolor = -1;            /* no color (rgb) to change    */
  57. changedirection = 0;            /* no color derection to change */
  58. incr = 999;                /* ready to randomize        */
  59. srand((unsigned)time(NULL));        /* randomize things        */
  60.  
  61. if (direction == 0) {            /* firing up in paused mode?    */
  62.     pauserotate();            /* then force a pause        */
  63.     direction = 1;            /* and set a rotate direction    */
  64.     }
  65.  
  66. maxreg = 256;                /* maximum register to rotate */
  67.  
  68. last = maxreg;                /* last box that was filled    */
  69. next = 1;                /* next box to be filled    */
  70. if (direction < 0) {
  71.     last = 1;
  72.     next = maxreg;
  73.     }
  74.  
  75. oldhelpmode = helpmode;            /* save the old help mode */
  76. helpmode = HELPCYCLING;            /* new help mode */
  77.  
  78. more = 1;
  79. while (more) {
  80.     while(!keypressed())    {    /* rotate until a key gets hit    */
  81.         if (fkey > 0) {        /* randomizing is on        */
  82.             for (istep = 0; istep < step; istep++) {
  83.                 jstep = next + (istep * direction);
  84.                 if (jstep <=      0) jstep += maxreg-1;
  85.                 if (jstep >= maxreg) jstep -= maxreg-1;
  86.                 if (++incr > fstep) {    /* time to randomize    */
  87.                     incr = 1;
  88.                     fstep = ((fsteps[fkey-1]*
  89.                         (rand() >> 8)) >> 6) + 1;
  90.                     fromred   = dacbox[last][0];
  91.                     fromgreen = dacbox[last][1];
  92.                     fromblue  = dacbox[last][2];
  93.                     tored     = rand() >> 9;
  94.                     togreen   = rand() >> 9;
  95.                     toblue    = rand() >> 9;
  96.                     }
  97.                 dacbox[jstep][0] = fromred   + (((tored   - fromred  )*incr)/fstep);
  98.                 dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
  99.                 dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
  100.                 }
  101.             if (step >= 256) step = oldstep;
  102.             }
  103.         spindac(direction, step);
  104.         }
  105.     kbdchar = getakey();
  106.     if (paused &&
  107.         (kbdchar != ' ' && kbdchar != 'c' && kbdchar != 'C' ))
  108.             paused = 0;    /* clear paused condition    */
  109.     switch (kbdchar) {
  110.         case '+':        /* '+' means rotate forward    */
  111.         case 1077:        /* RightArrow = rotate fwd    */
  112.             fkey = 0;
  113.             direction = 1;
  114.             last = maxreg-1;
  115.             next = 1;
  116.             incr = 999;
  117.             break;
  118.         case '-':        /* '-' means rotate backward    */
  119.         case 1075:        /* LeftArrow = rotate bkwd    */
  120.             fkey = 0;
  121.             direction = -1;
  122.             last = 1;
  123.             next = maxreg-1;
  124.             incr = 999;
  125.             break;
  126.         case 1072:        /* UpArrow means speed up    */
  127.             daclearn = 1;
  128.             if (daccount < 255) daccount++;
  129.             break;
  130.         case 1080:        /* DownArrow means slow down    */
  131.             daclearn = 1;
  132.             if (daccount > 1)   daccount--;
  133.             break;
  134.         case '1':
  135.         case '2':
  136.         case '3':
  137.         case '4':
  138.         case '5':
  139.         case '6':
  140.         case '7':
  141.         case '8':
  142.         case '9':
  143.             step = kbdchar - '0';    /* change step-size */
  144.             break;
  145.         case 1059:        /* F1 - F10:            */
  146.         case 1060:        /* select a shading factor     */
  147.         case 1061:
  148.         case 1062:
  149.         case 1063:
  150.         case 1064:
  151.         case 1065:
  152.         case 1066:
  153.         case 1067:
  154.         case 1068:
  155.             fkey = kbdchar-1058;
  156.             if (reallyega) fkey = (fkey+1)>>1; /* limit on EGA */
  157.             fstep = 1;
  158.             incr = 999;
  159.             break;
  160.         case 13:        /* enter key: randomize all colors */
  161.         case 1013:        /* also the Numeric-Keypad Enter */
  162.             fkey = rand()/3277 + 1;
  163.             if (reallyega)            /* limit on EGAs */
  164.                 fkey = (fkey+1)>>1;
  165.             fstep = 1;
  166.             incr = 999;
  167.             oldstep = step;
  168.             step = 256;
  169.             break;
  170.         case 'r':        /* color changes */
  171.             if (changecolor    == -1) changecolor = 0;
  172.             if (changedirection == 0) changedirection = -1;
  173.         case 'g':        /* color changes */
  174.             if (changecolor    == -1) changecolor = 1;
  175.             if (changedirection == 0) changedirection = -1;
  176.         case 'b':        /* color changes */
  177.             if (changecolor    == -1) changecolor = 2;
  178.             if (changedirection == 0) changedirection = -1;
  179.         case 'R':        /* color changes */
  180.             if (changecolor    == -1) changecolor = 0;
  181.             if (changedirection == 0) changedirection = 1;
  182.         case 'G':        /* color changes */
  183.             if (changecolor    == -1) changecolor = 1;
  184.             if (changedirection == 0) changedirection = 1;
  185.         case 'B':        /* color changes */
  186.             if (changecolor    == -1) changecolor = 2;
  187.             if (changedirection == 0) changedirection = 1;
  188.             if (reallyega) break;    /* no sense on real EGAs */
  189.             for (i = 1; i < 256; i++) {
  190.                 dacbox[i][changecolor] += changedirection;
  191.                 if (dacbox[i][changecolor] == 64)
  192.                     dacbox[i][changecolor] = 63;
  193.                 if (dacbox[i][changecolor] == 255)
  194.                     dacbox[i][changecolor] = 0;
  195.                 }
  196.             changecolor    = -1;    /* clear flags for next time */
  197.             changedirection = 0;
  198.             paused          = 0;    /* clear any pause */
  199.         case ' ':        /* use the spacebar as a "pause" toggle */
  200.         case 'c':        /* for completeness' sake, the 'c' too */
  201.         case 'C':
  202.             pauserotate();    /* pause */
  203.             break;
  204.         case 'd':        /* load colors from "default.map" */
  205.         case 'D':
  206.             findpath("default.map",temp1);
  207.             dacfile = fopen(temp1,"r");
  208.             if (dacfile == NULL) {
  209.                 buzzer(2);
  210.                 break;
  211.                 }
  212.             ValidateLuts(dacfile);    /* read the palette file */
  213.             fclose(dacfile);
  214.             fkey = 0;    /* disable random generation */
  215.             pauserotate();    /* update palette and pause */
  216.             break;
  217.         case 'a':        /* load colors from "altern.map" */
  218.         case 'A':
  219.             findpath("altern.map",temp1);
  220.             dacfile = fopen(temp1,"r");
  221.             if (dacfile == NULL) {
  222.                 buzzer(2);
  223.                 break;
  224.                 }
  225.             ValidateLuts(dacfile);    /* read the palette file */
  226.             fclose(dacfile);
  227.             fkey = 0;    /* disable random generation */
  228.             pauserotate();    /* update palette and pause */
  229.             break;
  230.         case 'm':        /* load colors from a specified map */
  231.         case 'M':
  232.             {
  233.             char temp2[80];
  234.             setfortext();
  235.             printf("\n\n Please enter your .MAP file name ==> ");
  236.             gets(temp2);
  237.             if (strchr(temp2,'.') == NULL)
  238.                 strcat(temp2,".map");
  239.             findpath(temp2,temp1);
  240.             setforgraphics();
  241.             }
  242.             dacfile = fopen(temp1,"r");
  243.             if (dacfile == NULL) {
  244.                 buzzer(2);
  245.                 break;
  246.                 }
  247.             ValidateLuts(dacfile);    /* read the palette file */
  248.             fclose(dacfile);
  249.             fkey = 0;    /* disable random generation */
  250.             pauserotate();    /* update palette and pause */
  251.             break;
  252.         case 's':        /* save the palette */
  253.         case 'S':
  254.             setfortext();
  255.             printf("\n\n Please enter your .MAP file name ==> ");
  256.             gets(temp1);
  257.             if (strchr(temp1,'.') == NULL)
  258.                 strcat(temp1,".map");
  259.             setforgraphics();
  260.             dacfile = fopen(temp1,"w");
  261.             if (dacfile == NULL) {
  262.                 buzzer(2);
  263.                 break;
  264.                 }
  265.             fprintf(dacfile,"  0   0   0\n");
  266.             for (i = 1; i < 256; i++) 
  267.                 fprintf(dacfile, "%3d %3d %3d\n",
  268.                 dacbox[i][0] << 2,
  269.                 dacbox[i][1] << 2,
  270.                 dacbox[i][2] << 2);
  271.             fclose(dacfile);
  272.             fkey = 0;    /* disable random generation */
  273.             pauserotate();    /* update palette and pause */
  274.             break;
  275.         default:        /* maybe a new palette, maybe bail-out */
  276.         if (kbdchar < 1084 || kbdchar > 1113) {
  277.             more = 0;    /* time to bail out */
  278.             break;
  279.             }
  280.             if (reallyega) break;    /* no sense on real EGAs */
  281.             fkey = 0;        /* disable random generation */
  282.             if (kbdchar == 1084)
  283.                 set_palette(Black, White);
  284.             if (kbdchar == 1085)
  285.                 set_palette(Red, Yellow);
  286.             if (kbdchar == 1086)
  287.                 set_palette(Blue, Green);
  288.             if (kbdchar == 1087)
  289.                 set_palette(Black, Yellow);
  290.             if (kbdchar == 1088)
  291.                 set_palette(Black, Red);
  292.             if (kbdchar == 1089)
  293.                 set_palette(Black, Blue);
  294.             if (kbdchar == 1090)
  295.                 set_palette(Black, Green);
  296.             if (kbdchar == 1091)
  297.                 set_palette(Blue, Yellow);
  298.             if (kbdchar == 1092)
  299.                 set_palette(Red, Green);
  300.             if (kbdchar == 1093)
  301.                 set_palette(Green, White);
  302.             if (kbdchar == 1094)
  303.                 set_palette2(Black, White);
  304.             if (kbdchar == 1095)
  305.                 set_palette2(Red, Yellow);
  306.             if (kbdchar == 1096)
  307.                 set_palette2(Blue, Green);
  308.             if (kbdchar == 1097)
  309.                 set_palette2(Black, Yellow);
  310.             if (kbdchar == 1098)
  311.                 set_palette2(Black, Red);
  312.             if (kbdchar == 1099)
  313.                 set_palette2(Black, Blue);
  314.             if (kbdchar == 1100)
  315.                 set_palette2(Black, Green);
  316.             if (kbdchar == 1101)
  317.                 set_palette2(Blue, Yellow);
  318.             if (kbdchar == 1102)
  319.                 set_palette2(Red, Green);
  320.             if (kbdchar == 1103)
  321.                 set_palette2(Green, White);
  322.             if (kbdchar == 1104)
  323.                 set_palette3(Blue, Green, Red);
  324.             if (kbdchar == 1105)
  325.                 set_palette3(Blue, Yellow, Red);
  326.             if (kbdchar == 1106)
  327.                 set_palette3(Red, White, Blue);
  328.             if (kbdchar == 1107)
  329.                 set_palette3(Red, Yellow, White);
  330.             if (kbdchar == 1108)
  331.                 set_palette3(Black, Brown, Yellow);
  332.             if (kbdchar == 1109)
  333.                 set_palette3(Blue, Brown, Green);
  334.             if (kbdchar == 1110)
  335.                 set_palette3(Blue, Green, Green);
  336.             if (kbdchar == 1111)
  337.                 set_palette3(Blue, Green, White);
  338.             if (kbdchar == 1112)
  339.                 set_palette3(Green, Green, White);
  340.             if (kbdchar == 1113)
  341.                 set_palette3(Red, Blue, White);
  342.             pauserotate();    /* update palette and pause */
  343.             break;
  344.         }
  345.     }
  346.  
  347. helpmode = oldhelpmode;            /* return to previous help mode */
  348. }
  349.  
  350. pauserotate()                /* pause-the-rotate routine */
  351. {
  352. int olddaccount;            /* saved dac-count value goes here */
  353.  
  354. if (paused) {    /* if already paused , just clear */
  355.     paused = 0;
  356.     }
  357. else {                    /* else set border, wait for a key */
  358.     olddaccount = daccount;
  359.     daccount = 256;
  360.     dacbox[0][0] = 63;
  361.     dacbox[0][1] = 63;
  362.     dacbox[0][2] = 63;
  363.     spindac(0,1);            /* show white border */
  364.     while (!keypressed());        /* wait for any key */
  365.     dacbox[0][0] = 0;
  366.     dacbox[0][1] = 0;
  367.     dacbox[0][2] = 0;
  368.     spindac(0,1);            /* show black border */
  369.     daccount = olddaccount;
  370.     paused = 1;
  371.     }
  372. }
  373.  
  374. set_palette(start, finish)
  375. unsigned char start[3], finish[3];
  376. {
  377.    int i, j;
  378.    for(i=1;i<=255;i++)            /* fill the palette    */
  379.       for (j = 0; j < 3; j++)
  380.          dacbox[i][j] = (i*start[j] + (256-i)*finish[j])/255;
  381. }
  382.  
  383. set_palette2(start, finish)
  384. unsigned char start[3], finish[3];
  385. {
  386.    int i, j;
  387.    for(i=1;i<=128;i++) 
  388.       for (j = 0; j < 3; j++) {
  389.          dacbox[i][j]     = (i*finish[j] + (128-i)*start[j] )/128;
  390.          dacbox[i+127][j] = (i*start[j]  + (128-i)*finish[j])/128;
  391.       }
  392. }
  393.  
  394. set_palette3(start, middle, finish)
  395. unsigned char start[3], middle[3], finish[3];
  396. {
  397.    int i, j;
  398.    for(i=1;i<=85;i++) 
  399.       for (j = 0; j < 3; j++) {
  400.          dacbox[i][j]     = (i*middle[j] + (86-i)*start[j] )/85;
  401.          dacbox[i+85][j]  = (i*finish[j] + (86-i)*middle[j])/85;
  402.          dacbox[i+170][j] = (i*start[j]  + (86-i)*finish[j])/85;
  403.       }
  404. }
  405.