home *** CD-ROM | disk | FTP | other *** search
/ Mega A/V / mega_av.zip / mega_av / GRAPHUTL / FRPOR172.ZIP / ROTATE.C < prev    next >
C/C++ Source or Header  |  1992-03-02  |  15KB  |  466 lines
  1. /*
  2.     rotate.c - Routines that manipulate the Video DAC on VGA Adapters
  3.     This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
  4. */
  5.  
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include "fractint.h"
  10. #include "helpdefs.h"
  11.  
  12. /* routines in this module    */
  13.  
  14. void rotate_overlay(void);
  15. void rotate(int);
  16. void save_palette(void);
  17. void load_palette(void);
  18.  
  19. static void pauserotate(void);
  20. static void set_palette(),set_palette2(),set_palette3();
  21.  
  22. extern char temp1[];
  23.  
  24. extern    int    colors;         /* maximum colors available */
  25.  
  26. extern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
  27. extern    int    gotrealdac;        /* dacbox valid? */
  28. extern BYTE olddacbox[256][3];
  29. extern int    daclearn, daccount;    /* used by the color-cyclers */
  30. extern int    reallyega;        /* == 0 if it's really an EGA */
  31. extern int    rotate_lo,rotate_hi;    /* range of colors to cycle */
  32. extern int    colorstate; /* comments in cmdfiles */
  33. extern char    colorfile[];
  34. extern int    dotmode;
  35.  
  36. static int paused;            /* rotate-is-paused flag */
  37.  
  38. extern int field_prompt(int options, char *hdg, char *instr, char *fld, int len,
  39.         int (*checkkey)() );
  40.  
  41. static BYTE Red[3]    = {63, 0, 0};    /* for shifted-Fkeys */
  42. static BYTE Green[3]  = { 0,63, 0};
  43. static BYTE Blue[3]   = { 0, 0,63};
  44. static BYTE Black[3]  = { 0, 0, 0};
  45. static BYTE White[3]  = {63,63,63};
  46. static BYTE Yellow[3] = {63,63, 0};
  47. static BYTE Brown[3]  = {31,31, 0};
  48.  
  49. char mapmask[13] = {"*.map"};
  50.  
  51.  
  52. void rotate_overlay() { }    /* for restore_active_ovly */
  53.  
  54. void rotate(int direction)    /* rotate-the-palette routine */
  55. {
  56. int  kbdchar, more, last, next;
  57. int fkey, step, fstep, istep, jstep, oldstep;
  58. int incr, fromred, fromblue, fromgreen, tored, toblue, togreen;
  59. int i, changecolor, changedirection;
  60. int oldhelpmode;
  61. int rotate_max,rotate_size;
  62.  
  63. static int fsteps[] = {2,4,8,12,16,24,32,40,54,100}; /* (for Fkeys) */
  64.  
  65.    ENTER_OVLY(OVLY_ROTATE);
  66.  
  67.    if (gotrealdac == 0            /* ??? no DAC to rotate! */
  68.      || colors < 16) {            /* strange things happen in 2x modes */
  69.       buzzer(2);
  70.       EXIT_OVLY;
  71.       return;
  72.       }
  73.  
  74.    oldhelpmode = helpmode;        /* save the old help mode    */
  75.    helpmode = HELPCYCLING;        /* new help mode        */
  76.  
  77.    paused = 0;                /* not paused            */
  78.    fkey = 0;                /* no random coloring        */
  79.    oldstep = step = 1;            /* single-step            */
  80.    fstep = 1;
  81.    changecolor = -1;            /* no color (rgb) to change    */
  82.    changedirection = 0;         /* no color direction to change */
  83.    incr = 999;                /* ready to randomize        */
  84.    srand((unsigned)time(NULL));     /* randomize things        */
  85.  
  86.    if (direction == 0) {        /* firing up in paused mode?    */
  87.       pauserotate();            /* then force a pause        */
  88.       direction = 1;            /* and set a rotate direction    */
  89.       }
  90.  
  91.    rotate_max = (rotate_hi < colors) ? rotate_hi : colors-1;
  92.    rotate_size = rotate_max - rotate_lo + 1;
  93.    last = rotate_max;            /* last box that was filled    */
  94.    next = rotate_lo;            /* next box to be filled    */
  95.    if (direction < 0) {
  96.       last = rotate_lo;
  97.       next = rotate_max;
  98.       }
  99.  
  100.    more = 1;
  101.    while (more) {
  102.       if (dotmode == 11) {
  103.      if (!paused)
  104.         pauserotate();
  105.      }
  106.       else while(!keypressed()) { /* rotate until key hit, at least once so step=oldstep ok */
  107.      if (fkey > 0) {        /* randomizing is on */
  108.         for (istep = 0; istep < step; istep++) {
  109.            jstep = next + (istep * direction);
  110.            while (jstep < rotate_lo)  jstep += rotate_size;
  111.            while (jstep > rotate_max) jstep -= rotate_size;
  112.            if (++incr > fstep) {    /* time to randomize */
  113.           incr = 1;
  114.                   fstep = ((fsteps[fkey-1]* (rand15() >> 8)) >> 6) + 1;
  115.           fromred   = dacbox[last][0];
  116.           fromgreen = dacbox[last][1];
  117.           fromblue  = dacbox[last][2];
  118.                   tored     = rand15() >> 9;
  119.                   togreen   = rand15() >> 9;
  120.                   toblue    = rand15() >> 9;
  121.           }
  122.            dacbox[jstep][0] = fromred   + (((tored     - fromred  )*incr)/fstep);
  123.            dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
  124.            dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
  125.            }
  126.         }
  127.      if (step >= rotate_size) step = oldstep;
  128.      spindac(direction, step);
  129.      }
  130.       if (step >= rotate_size) step = oldstep;
  131.       kbdchar = getakey();
  132.       if (paused && (kbdchar != ' ' && kbdchar != 'c' && kbdchar != 'C' ))
  133.      paused = 0;            /* clear paused condition    */
  134.       switch (kbdchar) {
  135.      case '+':                      /* '+' means rotate forward     */
  136.          case RIGHT_ARROW:              /* RightArrow = rotate fwd      */
  137.         fkey = 0;
  138.         direction = 1;
  139.         last = rotate_max;
  140.         next = rotate_lo;
  141.         incr = 999;
  142.         break;
  143.      case '-':                      /* '-' means rotate backward    */
  144.          case LEFT_ARROW:               /* LeftArrow = rotate bkwd      */
  145.         fkey = 0;
  146.         direction = -1;
  147.         last = rotate_lo;
  148.         next = rotate_max;
  149.         incr = 999;
  150.         break;
  151.          case UP_ARROW:                 /* UpArrow means speed up       */
  152.         daclearn = 1;
  153.         if (++daccount >= colors) --daccount;
  154.         break;
  155.          case DOWN_ARROW:               /* DownArrow means slow down    */
  156.         daclearn = 1;
  157.         if (daccount > 1) daccount--;
  158.         break;
  159.      case '1':
  160.      case '2':
  161.      case '3':
  162.      case '4':
  163.      case '5':
  164.      case '6':
  165.      case '7':
  166.      case '8':
  167.      case '9':
  168.         step = kbdchar - '0';   /* change step-size */
  169.         if (step > rotate_size) step = rotate_size;
  170.         break;
  171.          case F1:                       /* F1 - F10:                    */
  172.          case F2:                       /* select a shading factor      */
  173.          case F3:
  174.          case F4:
  175.          case F5:
  176.          case F6:
  177.          case F7:
  178.          case F8:
  179.          case F9:
  180.          case F10:
  181. #ifndef XFRACT
  182.             fkey = kbdchar-1058;
  183. #else
  184.             switch (kbdchar) {
  185.                case F1:
  186.                   fkey = 1;break;
  187.                case F2:
  188.                   fkey = 2;break;
  189.                case F3:
  190.                   fkey = 3;break;
  191.                case F4:
  192.                   fkey = 4;break;
  193.                case F5:
  194.                   fkey = 5;break;
  195.                case F6:
  196.                   fkey = 6;break;
  197.                case F7:
  198.                   fkey = 7;break;
  199.                case F8:
  200.                   fkey = 8;break;
  201.                case F9:
  202.                   fkey = 9;break;
  203.                case F10:
  204.                   fkey = 10;break;
  205.             }
  206. #endif
  207.         if (reallyega) fkey = (fkey+1)>>1; /* limit on EGA */
  208.         fstep = 1;
  209.         incr = 999;
  210.         break;
  211.          case ENTER:                    /* enter key: randomize all colors */
  212.          case ENTER_2:                  /* also the Numeric-Keypad Enter */
  213.             fkey = rand15()/3277 + 1;
  214.         if (reallyega)        /* limit on EGAs */
  215.            fkey = (fkey+1)>>1;
  216.         fstep = 1;
  217.         incr = 999;
  218.         oldstep = step;
  219.         step = rotate_size;
  220.         break;
  221.      case 'r':                      /* color changes */
  222.         if (changecolor    == -1) changecolor = 0;
  223.      case 'g':                      /* color changes */
  224.         if (changecolor    == -1) changecolor = 1;
  225.      case 'b':                      /* color changes */
  226.         if (changecolor    == -1) changecolor = 2;
  227.         if (changedirection == 0) changedirection = -1;
  228.      case 'R':                      /* color changes */
  229.         if (changecolor    == -1) changecolor = 0;
  230.      case 'G':                      /* color changes */
  231.         if (changecolor    == -1) changecolor = 1;
  232.      case 'B':                      /* color changes */
  233.         if (dotmode == 11) break;
  234.         if (changecolor    == -1) changecolor = 2;
  235.         if (changedirection == 0) changedirection = 1;
  236.         if (reallyega) break;    /* no sense on real EGAs */
  237.         for (i = 1; i < 256; i++) {
  238.            dacbox[i][changecolor] += changedirection;
  239.            if (dacbox[i][changecolor] == 64)
  240.            dacbox[i][changecolor] = 63;
  241.            if (dacbox[i][changecolor] == 255)
  242.           dacbox[i][changecolor] = 0;
  243.            }
  244.         changecolor    = -1;    /* clear flags for next time */
  245.         changedirection = 0;
  246.         paused        = 0;    /* clear any pause */
  247.      case ' ':                      /* use the spacebar as a "pause" toggle */
  248.      case 'c':                      /* for completeness' sake, the 'c' too */
  249.      case 'C':
  250.         pauserotate();        /* pause */
  251.         break;
  252.      case '>':            /* single-step */
  253.      case '.':
  254.      case '<':
  255.      case ',':
  256.         if (kbdchar == '>' || kbdchar == '.') {
  257.            direction = 1;
  258.            last = rotate_max;
  259.            next = rotate_lo;
  260.            incr = 999;
  261.            }
  262.         else {
  263.            direction = -1;
  264.            last = rotate_lo;
  265.            next = rotate_max;
  266.            incr = 999;
  267.            }
  268.         fkey = 0;
  269.         spindac(direction,1);
  270.         if (! paused)
  271.            pauserotate();        /* pause */
  272.         break;
  273.      case 'd':                      /* load colors from "default.map" */
  274.      case 'D':
  275.         if (ValidateLuts("default") != 0)
  276.            break;
  277.         fkey = 0;            /* disable random generation */
  278.         pauserotate();        /* update palette and pause */
  279.         break;
  280.      case 'a':                      /* load colors from "altern.map" */
  281.      case 'A':
  282.         if (ValidateLuts("altern") != 0)
  283.            break;
  284.         fkey = 0;            /* disable random generation */
  285.         pauserotate();        /* update palette and pause */
  286.         break;
  287.      case 'l':                      /* load colors from a specified map */
  288. #ifndef XFRACT /* L is used for RIGHT_ARROW in Unix keyboard mapping */
  289.      case 'L':
  290. #endif
  291.         load_palette();
  292.         fkey = 0;            /* disable random generation */
  293.         pauserotate();        /* update palette and pause */
  294.         break;
  295.      case 's':                      /* save the palette */
  296.      case 'S':
  297.         save_palette();
  298.         fkey = 0;            /* disable random generation */
  299.         pauserotate();        /* update palette and pause */
  300.         break;
  301.          case ESC:                      /* escape */
  302.         more = 0;            /* time to bail out */
  303.         break;
  304.      default:            /* maybe a new palette */
  305.         if (reallyega) break;    /* no sense on real EGAs */
  306.         fkey = 0;            /* disable random generation */
  307.         if (kbdchar == 1084) set_palette(Black, White);
  308.         if (kbdchar == SF2) set_palette(Red, Yellow);
  309.         if (kbdchar == SF3) set_palette(Blue, Green);
  310.         if (kbdchar == SF4) set_palette(Black, Yellow);
  311.         if (kbdchar == SF5) set_palette(Black, Red);
  312.         if (kbdchar == SF6) set_palette(Black, Blue);
  313.         if (kbdchar == SF7) set_palette(Black, Green);
  314.         if (kbdchar == SF8) set_palette(Blue, Yellow);
  315.         if (kbdchar == SF9) set_palette(Red, Green);
  316.         if (kbdchar == 1093) set_palette(Green, White);
  317.         if (kbdchar == 1094) set_palette2(Black, White);
  318.         if (kbdchar == 1095) set_palette2(Red, Yellow);
  319.         if (kbdchar == 1096) set_palette2(Blue, Green);
  320.         if (kbdchar == 1097) set_palette2(Black, Yellow);
  321.         if (kbdchar == 1098) set_palette2(Black, Red);
  322.         if (kbdchar == 1099) set_palette2(Black, Blue);
  323.         if (kbdchar == 1100) set_palette2(Black, Green);
  324.         if (kbdchar == 1101) set_palette2(Blue, Yellow);
  325.         if (kbdchar == 1102) set_palette2(Red, Green);
  326.         if (kbdchar == 1103) set_palette2(Green, White);
  327.         if (kbdchar == 1104) set_palette3(Blue, Green, Red);
  328.         if (kbdchar == 1105) set_palette3(Blue, Yellow, Red);
  329.         if (kbdchar == 1106) set_palette3(Red, White, Blue);
  330.         if (kbdchar == 1107) set_palette3(Red, Yellow, White);
  331.         if (kbdchar == 1108) set_palette3(Black, Brown, Yellow);
  332.         if (kbdchar == 1109) set_palette3(Blue, Brown, Green);
  333.         if (kbdchar == 1110) set_palette3(Blue, Green, Green);
  334.         if (kbdchar == 1111) set_palette3(Blue, Green, White);
  335.         if (kbdchar == 1112) set_palette3(Green, Green, White);
  336.         if (kbdchar == 1113) set_palette3(Red, Blue, White);
  337.         pauserotate();  /* update palette and pause */
  338.         break;
  339.      }
  340.       }
  341.  
  342.    helpmode = oldhelpmode;        /* return to previous help mode */
  343.    EXIT_OVLY;
  344. }
  345.  
  346. static void pauserotate()        /* pause-the-rotate routine */
  347. {
  348. int olddaccount;            /* saved dac-count value goes here */
  349. BYTE olddac0,olddac1,olddac2;
  350.  
  351.    if (paused)                /* if already paused , just clear */
  352.       paused = 0;
  353.    else {                /* else set border, wait for a key */
  354.       olddaccount = daccount;
  355.       olddac0 = dacbox[0][0];
  356.       olddac1 = dacbox[0][1];
  357.       olddac2 = dacbox[0][2];
  358.       daccount = 256;
  359.       dacbox[0][0] = 48;
  360.       dacbox[0][1] = 48;
  361.       dacbox[0][2] = 48;
  362.       spindac(0,1);            /* show white border */
  363.       if (dotmode == 11)
  364.          dvid_status(100," Paused in \"color cycling\" mode ");
  365. #ifndef XFRACT
  366.       while (!keypressed());          /* wait for any key */
  367. #else
  368.       waitkeypressed(0);                /* wait for any key */
  369. #endif
  370.       if (dotmode == 11)
  371.      dvid_status(0,"");
  372.       dacbox[0][0] = olddac0;
  373.       dacbox[0][1] = olddac1;
  374.       dacbox[0][2] = olddac2;
  375.       spindac(0,1);            /* show black border */
  376.       daccount = olddaccount;
  377.       paused = 1;
  378.       }
  379. }
  380.  
  381. static void set_palette(start, finish)
  382. BYTE start[3], finish[3];
  383. {
  384.    int i, j;
  385.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  386.    for(i=1;i<=255;i++)            /* fill the palette    */
  387.       for (j = 0; j < 3; j++)
  388.      dacbox[i][j] = (i*start[j] + (256-i)*finish[j])/255;
  389. }
  390.  
  391. static void set_palette2(start, finish)
  392. BYTE start[3], finish[3];
  393. {
  394.    int i, j;
  395.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  396.    for(i=1;i<=128;i++)
  397.       for (j = 0; j < 3; j++) {
  398.      dacbox[i][j]      = (i*finish[j] + (128-i)*start[j] )/128;
  399.      dacbox[i+127][j] = (i*start[j]  + (128-i)*finish[j])/128;
  400.       }
  401. }
  402.  
  403. static void set_palette3(start, middle, finish)
  404. BYTE start[3], middle[3], finish[3];
  405. {
  406.    int i, j;
  407.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  408.    for(i=1;i<=85;i++)
  409.       for (j = 0; j < 3; j++) {
  410.      dacbox[i][j]      = (i*middle[j] + (86-i)*start[j] )/85;
  411.      dacbox[i+85][j]  = (i*finish[j] + (86-i)*middle[j])/85;
  412.      dacbox[i+170][j] = (i*start[j]  + (86-i)*finish[j])/85;
  413.       }
  414. }
  415.  
  416.  
  417. void save_palette()
  418. {
  419.    FILE *dacfile;
  420.    int i,oldhelpmode;
  421.    oldhelpmode = helpmode;
  422.    stackscreen();
  423.    temp1[0] = 0;
  424.    helpmode = HELPCOLORMAP;
  425.    i = field_prompt(0,"Name of map file to write",NULL,temp1,60,NULL);
  426.    unstackscreen();
  427.    if (i != -1 && temp1[0]) {
  428.       if (strchr(temp1,'.') == NULL)
  429.      strcat(temp1,".map");
  430.       dacfile = fopen(temp1,"w");
  431.       if (dacfile == NULL)
  432.      buzzer(2);
  433.       else {
  434.      for (i = 0; i < colors; i++)
  435.         fprintf(dacfile, "%3d %3d %3d\n",
  436.             dacbox[i][0] << 2,
  437.             dacbox[i][1] << 2,
  438.             dacbox[i][2] << 2);
  439.      memcpy(olddacbox,dacbox,256*3);
  440.      colorstate = 2;
  441.      strcpy(colorfile,temp1);
  442.      }
  443.       fclose(dacfile);
  444.       }
  445.    helpmode = oldhelpmode;
  446. }
  447.  
  448.  
  449. void load_palette(void)
  450. {
  451.    int i,oldhelpmode;
  452.    char filename[80];
  453.    oldhelpmode = helpmode;
  454.    strcpy(filename,colorfile);
  455.    stackscreen();
  456.    helpmode = HELPCOLORMAP;
  457.    i = getafilename("Select a MAP File",mapmask,filename);
  458.    unstackscreen();
  459.    if (i >= 0)
  460.       if (ValidateLuts(filename) == 0)
  461.      memcpy(olddacbox,dacbox,256*3);
  462.    helpmode = oldhelpmode;
  463. }
  464.  
  465.  
  466.