home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / glview.sit / glview.src / fades.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-16  |  10.3 KB  |  410 lines
  1. /*
  2.  * Mac hack of
  3.  * fades.c - grasp image fader.
  4.  *
  5.  * Copyright (c) 1991 by Patrick J. Naughton
  6.  */
  7.  
  8. #pragma segment Fades
  9.  
  10. #include "grasp.h"
  11.  
  12.  
  13. #define FADE_SNAP    0
  14. #define FADE_WIPELR    1
  15. #define FADE_WIPERL    2
  16. #define FADE_WIPESC    3
  17. #define FADE_WIPECS    4
  18. #define FADE_ILACESIM    5
  19. #define FADE_ILACE    6
  20. #define FADE_WIPETLRBRL    7
  21. #define FADE_WIPELLRRLR    8
  22. #define FADE_WIPETB    9
  23. #define FADE_WIPEBT    10
  24. #define FADE_WIPETCBC    11
  25. #define FADE_WIPECTB    12
  26. #define FADE_ILACETBBT    13
  27. #define FADE_WIPETTBBTB    14
  28. #define FADE_WIPELTBRBT    15
  29. #define FADE_QUARTERS    16
  30. #define FADE_COLUMNS    17
  31. #define FADE_DOUBLEINT    18
  32. #define FADE_POUR    19
  33. #define FADE_SPARKLE    20
  34. #define FADE_DIAGONAL    21
  35. #define FADE_OPEN_AP    22
  36. #define FADE_CLOSE_AP    23
  37. #define FADE_CLOCK    24
  38. #define FADE_DOUBLEARC    25
  39.  
  40. #define ILACEW 16
  41. #define WIPEW 4
  42.  
  43. extern ImageStruct *picreg[16];
  44.  
  45. void
  46. imagefade(fadestyle, im, xo, yo, speed, clip)
  47.     int         fadestyle;
  48.     ImageStruct *im;
  49.     int         speed;
  50.     int         xo;
  51.     int         yo;
  52.     int         clip;
  53. {
  54.     int         i;
  55.     int         j;
  56.     int         k;
  57.     int         w = im->w;
  58.     int         h = im->h;
  59.     int         halfh = (h + 1) / 2;
  60.     int         halfw = (w + 1) / 2;
  61.     int         hpar = h & 1;
  62.     int         wpar = w & 1;
  63.  
  64.     if (videomode < '4') {
  65.     int         lastattr = -1;
  66. //    XImage     *xim = XGetImage(dsp, im->pix, 0, 0, w, h, 0xff, ZPixmap);
  67.     for (j = 0; j < h; j++) {
  68.         char       *row = "";
  69. //        char       *row = &xim->data[j * w];
  70.     
  71.         for (i = 0; i < w / 2;) {
  72.         char        s[81];
  73.         char        attr = 0;
  74.  
  75.         k = i;
  76.         do {
  77.             char        attr1 = row[2 * k + 1];
  78.             char        ch = row[2 * k];
  79.  
  80.             if (ch == 0)
  81.             s[k - i] = 32;
  82.             else {
  83.             s[k - i] = ch;
  84.             if (attr == 0) {
  85.                 if (attr1 != 0)
  86.                 attr = attr1;
  87.             } else if (attr != attr1)
  88.                 break;
  89.             }
  90.             k++;
  91.         } while (k < w / 2);
  92.         s[k - i] = 0;
  93.         if (attr != lastattr) {
  94.              XSetForeground(dsp, gc, attr & 0x0f);
  95.              XSetBackground(dsp, gc, (attr >> 4) & 0x0f);
  96.             lastattr = attr;
  97.         }
  98.          XDrawImageString(dsp, win, gc, i * 8, (j + 1) * 13 - 1, s, k - i);
  99.         i = k;
  100.         }
  101.     }
  102. //    free(xim->data);
  103. //    free(xim);
  104.     return;
  105.     }
  106.  
  107.     if (clip)
  108.         XSetClipRectangles(dsp, gc, 0, 0, &window, 1, 0);
  109.  
  110.     switch (fadestyle) {
  111.  
  112.     default:
  113.  
  114.     case FADE_SNAP:    // 0 -/
  115.     XCopyArea(dsp, im->pix, win, gc,
  116.           0, 0, w, h, xo, yo);
  117.     break;
  118.     
  119.     case FADE_WIPELR:    // 1 -/
  120.     for (i = 0; i < w; i += WIPEW)
  121.         XCopyArea(dsp, im->pix, win, gc,
  122.               i, 0, WIPEW, h, xo + i, yo);
  123.     break;
  124.  
  125.     case FADE_WIPERL:    // 2 -/
  126.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  127.         XCopyArea(dsp, im->pix, win, gc,
  128.               i, 0, WIPEW, h, xo + i, yo);
  129.     break;
  130.  
  131.     case FADE_WIPESC:    // 3 -/
  132.     for (i = 0; i <= halfw; i += WIPEW) {
  133.         XCopyArea(dsp, im->pix, win, gc,
  134.               i, 0, WIPEW, h, xo + i, yo + 0);
  135.         XCopyArea(dsp, im->pix, win, gc,
  136.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  137.     }
  138.     break;
  139.  
  140.     case FADE_WIPECS:    // 4 -/
  141.     for (i = halfw; i >= -WIPEW; i -= WIPEW) {
  142.         XCopyArea(dsp, im->pix, win, gc,
  143.               i, 0, WIPEW, h, xo + i, yo);
  144.         XCopyArea(dsp, im->pix, win, gc,
  145.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  146.     }
  147.     break;
  148.  
  149.     case FADE_ILACESIM:    // 5 -/
  150.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  151.         for (j = 0; j < h; j += 2) {
  152.         XCopyArea(dsp, im->pix, win, gc,
  153.               i, j, ILACEW, 1, xo + i, yo + j);
  154.         XCopyArea(dsp, im->pix, win, gc,
  155.               w - ILACEW - i, j + 1, ILACEW, 1,
  156.               xo + w - ILACEW - i, yo + j + 1);
  157.         }
  158.     break;
  159.  
  160.     case FADE_ILACE:    // 6 -/
  161.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  162.         for (j = 0; j < h; j += 2)
  163.         XCopyArea(dsp, im->pix, win, gc,
  164.               i, j, ILACEW, 1, xo + i, yo + j);
  165.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  166.         for (j = 0; j < h; j += 2)
  167.         XCopyArea(dsp, im->pix, win, gc,
  168.               w - ILACEW - i, j + 1, ILACEW, 1,
  169.               xo + w - ILACEW - i, yo + j + 1);
  170.     break;
  171.  
  172.     case FADE_WIPETLRBRL:    // 7 -/
  173.     for (i = 0; i <= w - WIPEW; i += WIPEW)
  174.         XCopyArea(dsp, im->pix, win, gc,
  175.               i, halfh, WIPEW, h - halfh, xo + i, yo + halfh);
  176.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  177.         XCopyArea(dsp, im->pix, win, gc,
  178.               i, 0, WIPEW, halfh, xo + i, yo);
  179.     break;
  180.  
  181.     case FADE_WIPELLRRLR:    // 8 -/
  182.     for (i = 0; i < halfw; i += WIPEW) {
  183.         XCopyArea(dsp, im->pix, win, gc,
  184.               i, 0, WIPEW, h, xo + i, yo);
  185.         XCopyArea(dsp, im->pix, win, gc,
  186.               halfw + i, 0, WIPEW, h, xo + halfw + i, yo);
  187.     }
  188.     break;
  189.  
  190.     case FADE_WIPETB:    // 9 -/
  191.     for (j = 0; j < h; j++)
  192.         XCopyArea(dsp, im->pix, win, gc,
  193.               0, j, w, 1, xo, yo + j);
  194.     break;
  195.  
  196.     case FADE_WIPEBT:    // 10 -/
  197.     for (j = h; j >= 0; j--)
  198.         XCopyArea(dsp, im->pix, win, gc,
  199.               0, j, w, 1, xo, yo + j);
  200.     break;
  201.  
  202.     case FADE_WIPETCBC:    // 11 -/
  203.     for (j = 0; j < halfh + hpar; j++) {
  204.         XCopyArea(dsp, im->pix, win, gc,
  205.               0, j, w, 1, xo, yo + j);
  206.         XCopyArea(dsp, im->pix, win, gc,
  207.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  208.     }
  209.     break;
  210.  
  211.     case FADE_WIPECTB:    // 12 -/
  212.     for (j = halfh + hpar - 1; j >= 0; j--) {
  213.         XCopyArea(dsp, im->pix, win, gc,
  214.               0, j, w, 1, xo, yo + j);
  215.         XCopyArea(dsp, im->pix, win, gc,
  216.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  217.     }
  218.     break;
  219.  
  220.     case FADE_ILACETBBT:    // 13 -/
  221.     for (j = 0; j < h; j += 2) {
  222.         XCopyArea(dsp, im->pix, win, gc,
  223.               0, j, w, 1, xo, yo + j);
  224.         XSync(dsp, False);
  225.     }
  226.     for (j = h - 1 - hpar; j > 0; j -= 2) {
  227.         XCopyArea(dsp, im->pix, win, gc,
  228.               0, j, w, 1, xo, yo + j);
  229.         XSync(dsp, False);
  230.     }
  231.     break;
  232.  
  233.     case FADE_WIPETTBBTB:    // 14 -/
  234.     for (j = 0; j < halfh + hpar; j++) {
  235.         XCopyArea(dsp, im->pix, win, gc,
  236.               0, j, w, 1, xo, yo + j);
  237.         XCopyArea(dsp, im->pix, win, gc,
  238.               0, halfh + j, w, 1, xo, yo + halfh + j);
  239.         XSync(dsp, False);
  240.     }
  241.     break;
  242.  
  243.     case FADE_WIPELTBRBT:    // 15 -/
  244.     for (j = 0; j < h; j++) {
  245.         XCopyArea(dsp, im->pix, win, gc,
  246.               0, j, halfw, 1, xo, yo + j);
  247.         XCopyArea(dsp, im->pix, win, gc,
  248.               halfw, h - j, halfw, 1, xo + halfw, yo + h - j);
  249.         XSync(dsp, False);
  250.     }
  251.     break;
  252.  
  253.     case FADE_QUARTERS:    // 16 -/
  254.  
  255.     // top left, top to bottom -/
  256.     for (j = 0; j <= halfh + hpar; j++) {
  257.         XCopyArea(dsp, im->pix, win, gc,
  258.               0, j, halfw + wpar, 1, xo, yo + j);
  259.         XSync(dsp, False);
  260.     }
  261.  
  262.     // bottom right, top to bottom -/
  263.     for (j = halfh + hpar; j < h; j++) {
  264.         XCopyArea(dsp, im->pix, win, gc,
  265.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  266.         XSync(dsp, False);
  267.     }
  268.  
  269.     // bottom left, bottom to top -/
  270.     for (j = h; j >= halfh; j--) {
  271.         XCopyArea(dsp, im->pix, win, gc,
  272.               0, j, halfw + wpar, 1, xo, yo + j);
  273.         XSync(dsp, False);
  274.     }
  275.  
  276.     // top right, bottom to top -/
  277.     for (j = halfh; j >= 0; j--) {
  278.         XCopyArea(dsp, im->pix, win, gc,
  279.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  280.         XSync(dsp, False);
  281.     }
  282.     break;
  283.  
  284.     case FADE_COLUMNS:    // 17 -/
  285.     for (j = 0; j < h; j += 2)
  286.         for (i = 0; i < w; i += 16)
  287.         XCopyArea(dsp, im->pix, win, gc,
  288.               i, j, 8, 2, xo + i, yo + j);
  289.  
  290.     for (j = h - 1; j >= -1; j -= 2)
  291.         for (i = 8; i < w; i += 16)
  292.         XCopyArea(dsp, im->pix, win, gc,
  293.               i, j, 8, 2, xo + i, yo + j);
  294.  
  295.     break;
  296.  
  297.     case FADE_DOUBLEINT:    // 18 -/
  298.     for (j = 0; j < h; j += 2)
  299.         for (i = 0; i < w; i += 16)
  300.         XCopyArea(dsp, im->pix, win, gc,
  301.               i, j, 8, 1, xo + i, yo + j);
  302.     for (j = h - 1; j >= 0; j -= 2)
  303.         for (i = 8; i < w; i += 16)
  304.         XCopyArea(dsp, im->pix, win, gc,
  305.               i, j, 8, 1, xo + i, yo + j);
  306.     for (j = 1; j < h; j += 2)
  307.         for (i = 0; i < w; i += 16)
  308.         XCopyArea(dsp, im->pix, win, gc,
  309.               i, j, 8, 1, xo + i, yo + j);
  310.     for (j = h - 2; j >= 0; j -= 2)
  311.         for (i = 8; i < w; i += 16)
  312.         XCopyArea(dsp, im->pix, win, gc,
  313.               i, j, 8, 1, xo + i, yo + j);
  314.     break;
  315.  
  316.     case FADE_POUR:    // 19 -/
  317.     for (j = h - 1; j >= 0; j -= WIPEW)
  318.         for (i = 0; i < j; i++)
  319.         XCopyArea(dsp, im->pix, win, gc,
  320.               0, j, w, WIPEW, xo + 0, yo + i);
  321.     break;
  322.  
  323.     case FADE_SPARKLE:    // 20 -/
  324.     {
  325.         int         boxsize = (w + 19) / 20; //(w + 39) / 40;
  326.         int         cols = (w + (boxsize - 1)) / boxsize;
  327.         int         boxcount = (h + (boxsize - 1)) / boxsize * cols;
  328.         int        *order = (int *) malloc(boxcount * sizeof(int));
  329.  
  330.         (void) srand(getpid());
  331.         for (i = 0; i < boxcount; i++)
  332.         order[i] = i;
  333.         for (i = 0; i < boxcount * boxsize; i++) {
  334.         int         i1 = rand() % boxcount;
  335.         int         i2 = rand() % boxcount;
  336.         j = order[i1];
  337.         order[i1] = order[i2];
  338.         order[i2] = j;
  339.         }
  340.         for (i = 0; i < boxcount; i++) {
  341.         int         x = (order[i] % cols) * boxsize;
  342.         int         y = (order[i] / cols) * boxsize;
  343.         XCopyArea(dsp, im->pix, win, gc,
  344.               x, y, boxsize, boxsize, xo + x, yo + y);
  345.         }
  346.         free(order);
  347.     }
  348.     break;
  349.  
  350.  
  351.     case FADE_DIAGONAL:    // 21 -/// not implemented -/
  352.     XCopyArea(dsp, im->pix, win, gc,
  353.           0, 0, w, h, xo, yo);
  354.     break;
  355.     case FADE_OPEN_AP:    // 22 -/
  356.     for (i = 0; i <= MAX(w, h) / 2; i += WIPEW) {
  357.         // left wedge -/
  358.         XCopyArea(dsp, im->pix, win, gc,
  359.               halfw - i, halfh - i, WIPEW, 2 * i,
  360.               xo + halfw - i, yo + halfh - i);
  361.         // top wedge -/
  362.         XCopyArea(dsp, im->pix, win, gc,
  363.               halfw - i, halfh - i, 2 * i, WIPEW,
  364.               xo + halfw - i, yo + halfh - i);
  365.         // right wedge -/
  366.         XCopyArea(dsp, im->pix, win, gc,
  367.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  368.               xo + halfw + i, yo + halfh - i);
  369.         // bottom wedge -/
  370.         XCopyArea(dsp, im->pix, win, gc,
  371.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  372.               xo + halfw - i, yo + halfh + i);
  373.         XSync(dsp, False);
  374.     }
  375.     break;
  376.     case FADE_CLOSE_AP:    // 23 -/
  377.     for (i = MAX(w, h) / 2; i >= 0; i -= WIPEW) {
  378.         // left wedge -/
  379.         XCopyArea(dsp, im->pix, win, gc,
  380.               halfw - i, halfh - i, WIPEW, 2 * i,
  381.               xo + halfw - i, yo + halfh - i);
  382.         // top wedge -/
  383.         XCopyArea(dsp, im->pix, win, gc,
  384.               halfw - i, halfh - i, 2 * i, WIPEW,
  385.               xo + halfw - i, yo + halfh - i);
  386.         // right wedge -/
  387.         XCopyArea(dsp, im->pix, win, gc,
  388.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  389.               xo + halfw + i, yo + halfh - i);
  390.         // bottom wedge -/
  391.         XCopyArea(dsp, im->pix, win, gc,
  392.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  393.               xo + halfw - i, yo + halfh + i);
  394.         XSync(dsp, False);
  395.     }
  396.     break;
  397.     case FADE_CLOCK:    // 24 -/// not implemented -/
  398.     XCopyArea(dsp, im->pix, win, gc,
  399.           0, 0, w, h, xo, yo);
  400.     break;
  401.     case FADE_DOUBLEARC:    // 25 -/// not implemented -/
  402.     XCopyArea(dsp, im->pix, win, gc,
  403.           0, 0, w, h, xo, yo);
  404.     break;
  405.  
  406.     }
  407.     XSetClipMask(dsp, gc, None);
  408.     XSync(dsp, False);
  409. }
  410.