home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3928 < prev    next >
Encoding:
Text File  |  1991-08-28  |  12.0 KB  |  436 lines
  1. Newsgroups: alt.sources
  2. Path: wupost!sdd.hp.com!decwrl!ampex!gregory
  3. From: gregory@ampex.com (Gregory Bloom)
  4. Subject: openlook sun4/60 cgthree color background animator  (01/01)
  5. Message-ID: <1991Aug26.231153.7315@ampex.com>
  6. Summary: provides color animation for backgrounds loaded with xloadimage
  7. Keywords: fun, hypnotic, psychedelic, productivity enhancement
  8. Organization: Ampex Corporation, Golden, CO
  9. Date: Mon, 26 Aug 1991 23:11:53 GMT
  10.  
  11.  
  12. Following are two programs that provide a nice color animated background
  13. for users of openlook on  color sun4s.  I have only tested this on my 
  14. sun 4/60 with cgthree0. It has a little problem with old sunview applications
  15. (it animates them, too).
  16.  
  17. The first program, bloom.c, creates a color gradient rasterfile which
  18. you can load onto your background using xsetbg (xloadimage). If you
  19. don't yet have xloadimage, ask your local net guru where you can
  20. get it.
  21.  
  22. The second program, phaze.c, opens your frame buffer, examines your
  23. colormap for gradient colors, then animates those colors it finds.
  24.  
  25. You can easily hack bloom.c to provide a wide variety of interesting
  26. color animated backgrounds.
  27.  
  28. I don't have shar, so y'all are going to have to search for the --cut here--
  29. marks.
  30.  
  31.  
  32. Have fun.
  33.  
  34.  
  35.  
  36. --------------------------------cut here------------------------------------
  37.  
  38.  
  39. /*/--------------------------------*\
  40. /*  bloom.c  create bloom.gr8       |
  41. /*                                  |
  42. /*  usage:                          |
  43. /*  cc -o bloom bloom.c -lm         |
  44. /*  bloom                           |
  45. /*  xsetbg bloom.gr8                |
  46. /*  phaze &                         |
  47. /*                                  |
  48. /*  bloom creates a 1152 x 900 grey-|
  49. /*  gradient image which has colors |
  50. /*  r = color number, g = r + 1,    |
  51. /*  b = r + 2 for its colormap      |
  52. /*  which you may use xloadimage    |
  53. /*  to set as your background       |
  54. /*  and then animate using phaze    |
  55. /*                                  |
  56. /*  Gregory Bloom  1991             |
  57. /*                                  |
  58. /*  gregory@ampex.com               |
  59. /*\--------------------------------*/
  60.  
  61. #include <rasterfile.h>
  62. #include <ctype.h>
  63. #include <stdio.h>
  64. #include <math.h>
  65.  
  66. #define   COLORINCREMENT  (.01)
  67. #define   ITERATIONS 30
  68. #define   COLORCOUNT 128
  69.  
  70. #define   RAS_MAGIC  0x59a66a95
  71. #define   TWO_PI    (6.283185307)
  72.  
  73.     /* ordered dither table */
  74. int dit[8][8] = {
  75.      0, 32,  8, 40,  2, 34, 10, 42,
  76.     48, 16, 56, 24, 50, 18, 58, 26,
  77.     12, 44,  4, 36, 14, 46,  6, 38,
  78.     60, 28, 52, 20, 62, 30, 54, 22,
  79.  
  80.      3, 35, 11, 43,  1, 33,  9, 41,
  81.     51, 19, 59, 27, 49, 17, 57, 25,
  82.     15, 47,  7, 39, 13, 45,  5, 37,
  83.     63, 31, 55, 23, 61, 29, 53, 21
  84. };
  85.  
  86. struct rasterfile  ras;
  87.  
  88. unsigned shift_reg;
  89. unsigned char screen[900][1152];
  90.  
  91. main(argc, argv)
  92. int argc;
  93. char **argv;
  94. {
  95.     FILE *fo;
  96.     double x, y, dx, dy;
  97.     int count, pass;
  98.     int color, ran;
  99.     unsigned char map[256], remap[256];
  100.     double color_float;
  101.     double floor (), frand ();
  102.     double sin (), cos ();
  103.     double fabs ();
  104.  
  105.     color_float = 0.0;
  106.  
  107.     x = 0;
  108.     y = 0;
  109.  
  110.     color = 0;
  111.  
  112.     srandom (time (0));
  113.  
  114.         /* choose random initial velocity */
  115.     for (dx = 0.0, dy = 0.0; dx == 0.0 && dy == 0.0;)
  116.     {
  117.         dx = (frand () / 5.0 + .1) - (frand () / 5.0 + .1);
  118.         dy = (frand () / 5.0 + .1) - (frand () / 5.0 + .1);
  119.     }
  120.  
  121.  
  122.     printf ("countdown:\n");
  123.     for (pass = 0; pass < ITERATIONS; pass++)
  124.     {
  125.         printf ("%d\n", ITERATIONS - pass);
  126.  
  127.             /* each pass is 1152 * 900 pixels */
  128.         for (count = 0; count < 1036800; count++)
  129.         {
  130.             ran = random ();
  131.  
  132.                 /* random walk + velocity */
  133.             x += (double)((ran & 1) - ((ran & 2) == 0)) + dx;
  134.             y += (double)(((ran & 4) == 0) - ((ran & 8) == 0)) + dy;
  135.  
  136.                 /* if offscreen, start again in center with new velocity */
  137.             if (x < 0.0 || x >= 1152.0 || y < 0.0 || y >= 900.0)
  138.             {
  139.                 for (dx = 0.0, dy = 0.0; 
  140.                      fabs (dx) <= 0.02 && fabs (dy) <= 0.02;)
  141.                 {
  142.                     dx = (frand () / 5.0 + .1) - (frand () / 5.0 + .1);
  143.                     dy = (frand () / 5.0 + .1) - (frand () / 5.0 + .1);
  144.                 }
  145.  
  146.                     /* reset to center */
  147.                 x = 1152.0 / 2.0;
  148.                 y = 900.0 / 2.0;
  149.  
  150.                     /* same starting color */
  151.                 color_float = 0.0;
  152.             }
  153.  
  154.  
  155.             color_float += COLORINCREMENT;
  156.  
  157.                 /* dither color fraction */
  158.             color = (int)color_float +
  159.                         ((int)(64.0 * (color_float - floor (color_float))) >
  160.                                 dit[(int)y & 7][(int)x & 7]);
  161.             color %= COLORCOUNT;
  162.  
  163.             screen[(int)y][(int)x] = color;
  164.         }
  165.     }
  166.     
  167.  
  168.         /* see rasterfile man page to figure this out */
  169.     ras.ras_magic = RAS_MAGIC;
  170.     ras.ras_width = 0x480;
  171.     ras.ras_height = 0x384;
  172.     ras.ras_depth = 0x08;
  173.     ras.ras_length = 0xfd200;
  174.     ras.ras_type = RT_STANDARD;
  175.     ras.ras_maptype = RMT_EQUAL_RGB;
  176.     ras.ras_maplength = 3 * COLORCOUNT;
  177.  
  178.     fo = fopen("bloom.gr8", "w");
  179.  
  180.     putw (ras.ras_magic, fo);
  181.     putw (ras.ras_width, fo);
  182.     putw (ras.ras_height, fo);
  183.     putw (ras.ras_depth, fo);
  184.     putw (ras.ras_length, fo);
  185.     putw (ras.ras_type, fo);
  186.     putw (ras.ras_maptype, fo);
  187.     putw (ras.ras_maplength, fo);
  188.  
  189.         /* create easily recognizable grey colormap */
  190.     for (color = 0; color < COLORCOUNT; color++)
  191.     {
  192.         putc (color, fo);
  193.     }
  194.     for (color = 0; color < COLORCOUNT; color++)
  195.     {
  196.         putc (color + 1, fo);
  197.     }
  198.     for (color = 0; color < COLORCOUNT; color++)
  199.     {
  200.         putc (color + 2, fo);
  201.     }
  202.  
  203.  
  204.         /* output */
  205.     for (y = 0; y < 900; y++)
  206.     {
  207.         for (x = 0; x < 1152; x++)
  208.         {
  209.             putc (screen[(int)y][(int)x], fo);
  210.         }
  211.     }
  212.     printf ("bloom.gr8 created\n");
  213. }
  214.  
  215. double
  216. frand ()
  217. {
  218.     return ((double) (random ()) / 2147483647.0);
  219. }
  220.  
  221.  
  222.  
  223. --------------------------------cut here------------------------------------
  224.  
  225.  
  226.  
  227. /*/--------------------------------*\
  228. /*  phaze.c  animate desktop colors |
  229. /*                                  |
  230. /*  usage on sun 4/60 with cgthree0:|
  231. /*  cc -o phaze phaze.c -lpixrect   |
  232. /*  xsetbg <file.gr8> (ie bloom.gr8)|
  233. /*  phaze &                         |
  234. /*                                  |
  235. /*  you need to have loaded a grey- | 
  236. /*  gradient image which has colors |
  237. /*  r = color number, g = r + 1,    |
  238. /*  b = r + 2 for its colormap      |
  239. /*                                  |
  240. /*  Gregory Bloom  1991             |
  241. /*                                  |
  242. /*  phaze is tuneware: (p-haze?)    |
  243. /*  I don't care what you do with it|
  244. /*  but if you have a CD of obscure |
  245. /*  tunes you think I should have,  |
  246. /*  lemme know about it.  Or, if the|
  247. /*  disk is just cluttering up your |
  248. /*  shelf, feel free to send it!    |
  249. /*                                  |
  250. /*  gregory@ampex.com               |
  251. /*                                  |
  252. /*  Gregory Bloom                   |
  253. /*  11540 West 100th Place          |
  254. /*  Broomfield, CO  80021           |
  255. /*                                  |
  256. /*\--------------------------------*/
  257.  
  258. #include <pixrect/pixrect_hs.h>
  259. #include <stdio.h>
  260.  
  261. #define  MAX_FREQUENCY 32
  262. #define  HELL_SLOWLY_FREEZES_OVER 1
  263.  
  264. main (argc, argv)
  265. int argc;
  266. char **argv;
  267. {
  268.     Pixrect *screen;
  269.     int rb, gb, bb;
  270.     int rs, gs, bs;
  271.     int rt, gt, bt;
  272.     int pause;
  273.     int index, back_index, count, maplen;
  274.     int step, sweep, value; 
  275.     int r_index, g_index, b_index;
  276.     int r_flip, g_flip, b_flip;
  277.     unsigned char ranbyte;
  278.  
  279.     unsigned char sr[257], sg[257], sb[257];
  280.     int remap[256];
  281.     unsigned char rcolor[2 * 256 * MAX_FREQUENCY + 256];
  282.     unsigned char gcolor[2 * 256 * MAX_FREQUENCY + 256];
  283.     unsigned char bcolor[2 * 256 * MAX_FREQUENCY + 256];
  284.  
  285.     int r_offset, g_offset, b_offset;
  286.     int mapCount;
  287.  
  288.  
  289.         /* init random */
  290.     srandom (time (0));
  291.  
  292.  
  293.         /* access screen */
  294.     screen = pr_open("/dev/fb");
  295.  
  296.     index = 0;
  297.     value = 0;
  298.  
  299.         /* set up random colormap with each r, g, and b ramp frequency */
  300.     for (step = 1; step <= MAX_FREQUENCY; step++)
  301.     {
  302.         for (sweep = 0; sweep < (MAX_FREQUENCY - step); sweep++)
  303.         {
  304.             value += step;
  305.  
  306.             rcolor[index] = value;
  307.             gcolor[index] = value;
  308.             bcolor[index] = value;
  309.             ++index;
  310.         }
  311.     }
  312.  
  313.         /* append backwards colormap */
  314.     for (count = index - 1; count >= 0; count--)
  315.     {
  316.         rcolor[index] = rcolor[count];
  317.         gcolor[index] = gcolor[count];
  318.         bcolor[index] = bcolor[count];
  319.         ++index;
  320.     }
  321.  
  322.         /* append start of forward colormap for clean wrap */
  323.     for (count = 0; count < 256; count++)
  324.     {
  325.         rcolor[index] = rcolor[count];
  326.         gcolor[index] = gcolor[count];
  327.         bcolor[index] = bcolor[count];
  328.         ++index;
  329.     }
  330.  
  331.     maplen = index;
  332.  
  333.  
  334.         /* start each color phaze at a random offset into map sequence */
  335.     r_offset = random () % maplen;
  336.     g_offset = random () % maplen;
  337.     b_offset = random () % maplen;
  338.  
  339.         /* each phaze starts running forward through colormap sequence */
  340.     r_flip = 0;
  341.     g_flip = 0;
  342.     b_flip = 0;
  343.  
  344.         /* get current colormap */
  345.     pr_getcolormap (screen, 0, 256, sr, sg, sb);
  346.  
  347.         /* default colors that are not ours off colormap */
  348.     for (count = 0; count < 256; count++)
  349.         remap[count] = 256;
  350.  
  351.         /* xloadimage sprays colors all through the colormap, so we need
  352.         /* to find each slot that our colors have been assigned.
  353.         /* for this reason, our colors are easily recognizable as:
  354.         /* r = color number,  g = r + 1,  b = r + 2
  355.         */
  356.     mapCount = 0;
  357.     for (count = 0; count < 256; count++)
  358.     {
  359.             /* is this one of our colors? */
  360.         if (sr[count] == sg[count] - 1 && 
  361.             sr[count] == sb[count] - 2 &&
  362.             sr[count] < sg[count] &&
  363.             sg[count] < sb[count])
  364.         {
  365.             ++mapCount;
  366.  
  367.                 /* keep track of where this color was in the current colormap
  368.                 /* (r = color number)
  369.                 */
  370.             remap[sr[count]] = count;
  371.         }
  372.     }
  373.  
  374.     while (HELL_SLOWLY_FREEZES_OVER)
  375.     {
  376.             /* step through colormap sequence */
  377.         for (index = 0; index < maplen - MAX_FREQUENCY; index++)
  378.         {
  379.                 /* back_index is for color phazes moving back thru sequence */
  380.             back_index = maplen - MAX_FREQUENCY - index;
  381.  
  382.             r_index = ((r_flip ? back_index : index) + r_offset) % maplen;
  383.             g_index = ((g_flip ? back_index : index) + g_offset) % maplen;
  384.             b_index = ((b_flip ? back_index : index) + b_offset) % maplen;
  385.  
  386.             for (count = 0; count < 256; count++)
  387.             {
  388.                 sr[remap[count]] = rcolor[r_index + count];
  389.                 sg[remap[count]] = gcolor[g_index + count];
  390.                 sb[remap[count]]  = bcolor[b_index + count];
  391.             }
  392.  
  393.             pr_putcolormap (screen, 0, 256, sr, sg, sb);
  394.  
  395.                 /* go do something useful for a while */
  396.             usleep (63000);
  397.  
  398.         }
  399.  
  400.         ranbyte = random () % 3;;
  401.  
  402.             /* after each pass, shift a color wrt the others, maybe reversing */
  403.         switch (ranbyte)
  404.         {
  405.             case 0:
  406.                 r_offset = (r_offset + ((random () % 3) - 1) + maplen) % maplen;
  407.                 if (r_flip != r_offset & 0x01)
  408.                 {
  409.                     r_offset = (maplen - MAX_FREQUENCY) - r_offset;
  410.                     r_flip = (r_flip == 0);
  411.                 }
  412.             break;
  413.  
  414.             case 1:
  415.                 g_offset = (g_offset + ((random () % 3) - 1) + maplen) % maplen;
  416.                 if (g_flip != g_offset & 0x01)
  417.                 {
  418.                     g_offset = (maplen - MAX_FREQUENCY) - g_offset;
  419.                     g_flip = (g_flip == 0);
  420.                 }
  421.             break;
  422.  
  423.             case 2:
  424.                 b_offset = (b_offset + ((random () % 3) - 1) + maplen) % maplen;
  425.                 if (b_flip != b_offset & 0x01)
  426.                 {
  427.                     b_offset = (maplen - MAX_FREQUENCY) - b_offset;
  428.                     b_flip = (b_flip == 0);
  429.                 }
  430.             break;
  431.         }
  432.     }
  433. }
  434.  
  435.  
  436.