Subversion Repositories or1k_old

/* erase.c: Erase the screen in various more or less interesting ways.

 * (c) 1997 by Johannes Keukelaar <johannes@nada.kth.se>

 * Permission to use in any way granted. Provided "as is" without expressed

 * or implied warranty. NO WARRANTY, NO EXPRESSION OF SUITABILITY FOR ANY

 * PURPOSE. (I.e.: Use in any way, but at your own risk!)

 */

#include <stdio.h>

//#include <unistd.h>

#define usleep(x)

#include <stdlib.h>

#include <math.h>

#define MWINCLUDECOLORS

#include "nano-X.h"

#include "maze.h"

#undef countof

#define countof(x) (sizeof(x)/sizeof(*(x)))

typedef void (*Eraser) (int width, int height, int delay, int granularity);

typedef int Bool;

static void

random_lines (int width, int height, int delay, int granularity)

{

  Bool horiz_p = (random() & 1);

  int max = (horiz_p ? height : width);

  int *lines = (int *) calloc(max, sizeof(*lines));

  int i;

  for (i = 0; i < max; i++)

    lines[i] = i;

  for (i = 0; i < max; i++)

    {

      int t, r;

      t = lines[i];

      r = random() % max;

      lines[i] = lines[r];

      lines[r] = t;

    }

  for (i = 0; i < max; i++)

    {

      if (horiz_p)

        GrLine (wid, erase_gc, 0, lines[i], width, lines[i]);

      else

        GrLine (wid, erase_gc, lines[i], 0, lines[i], height);

      wait_sync ();

      if (delay > 0 && ((i % granularity) == 0))

        usleep (delay * granularity);

    }

  free(lines);

}

static void

venetian (int width, int height, int delay, int granularity)

{

  Bool horiz_p = (random() & 1);

  Bool flip_p = (random() & 1);

  int max = (horiz_p ? height : width);

  int *lines = (int *) calloc(max, sizeof(*lines));

  int i, j;

  granularity /= 6;

  j = 0;

  for (i = 0; i < max*2; i++)

    {

      int line = ((i / 16) * 16) - ((i % 16) * 15);

      if (line >= 0 && line < max)

        lines[j++] = (flip_p ? max - line : line);

    }

  for (i = 0; i < max; i++)

    {

      if (horiz_p)

        GrLine (wid, erase_gc, 0, lines[i], width, lines[i]);

      else

        GrLine (wid, erase_gc, lines[i], 0, lines[i], height);

      wait_sync ();

      if (delay > 0 && ((i % granularity) == 0))

        usleep (delay * granularity);

    }

  free(lines);

}

static void

triple_wipe (int width, int height, int delay, int granularity)

{

  Bool flip_x = random() & 1;

  Bool flip_y = random() & 1;

  int max = width + (height / 2);

  int *lines = (int *)calloc(max, sizeof(int));

  int i;

  for(i = 0; i < width/2; i++)

    lines[i] = i*2+height;

  for(i = 0; i < height/2; i++)

    lines[i+width/2] = i*2;

  for(i = 0; i < width/2; i++)

    lines[i+width/2+height/2] = width-i*2-(width%2?0:1)+height;

  granularity /= 6;

  for (i = 0; i < max; i++)

    {

      int x, y, x2, y2;

      if (lines[i] < height)

        x = 0, y = lines[i], x2 = width, y2 = y;

      else

        x = lines[i]-height, y = 0, x2 = x, y2 = height;

      if (flip_x)

        x = width-x, x2 = width-x2;

      if (flip_y)

        y = height-y, y2 = height-y2;

      GrLine (wid, erase_gc, x, y, x2, y2);

      wait_sync ();

      if (delay > 0 && ((i % granularity) == 0))

        usleep (delay*granularity);

    }

  free(lines);

}

static void

quad_wipe (int width, int height, int delay, int granularity)

{

  Bool flip_x = random() & 1;

  Bool flip_y = random() & 1;

  int max = width + height;

  int *lines = (int *)calloc(max, sizeof(int));

  int i;

  granularity /= 3;

  for (i = 0; i < max/4; i++)

    {

      lines[i*4]   = i*2;

      lines[i*4+1] = height-i*2-(height%2?0:1);

      lines[i*4+2] = height+i*2;

      lines[i*4+3] = height+width-i*2-(width%2?0:1);

    }

  for (i = 0; i < max; i++)

    {

      int x, y, x2, y2;

      if (lines[i] < height)

        x = 0, y = lines[i], x2 = width, y2 = y;

      else

        x = lines[i]-height, y = 0, x2 = x, y2 = height;

      if (flip_x)

        x = width-x, x2 = width-x2;

      if (flip_y)

        y = height-y, y2 = height-y2;

      GrLine (wid, erase_gc, x, y, x2, y2);

      wait_sync ();

      if (delay > 0 && ((i % granularity) == 0))

        usleep (delay*granularity);

    }

  free(lines);

}

#if 0

static void

circle_wipe (int width, int height, int delay, int granularity)

{

  int full = 360 * 64;

  int inc = full / 64;

  int start = random() % full;

  int rad = (width > height ? width : height);

  int i;

  if (random() & 1)

    inc = -inc;

  for (i = (inc > 0 ? 0 : full);

       (inc > 0 ? i < full : i > 0);

       i += inc)

    {

      GrArc(wid, erase_gc,

               (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (i+start) % full, inc);

      usleep (delay*granularity);

    }

}

#endif

#if 0

static void

three_circle_wipe (int width, int height, int delay, int granularity)

{

  int i;

  int full = 360 * 64;

  int q = full / 6;

  int q2 = q * 2;

  int inc = full / 240;

  int start = random() % q;

  int rad = (width > height ? width : height);

  for (i = 0; i < q; i += inc)

    {

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start+i) % full, inc);

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start-i) % full, -inc);

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start+q2+i) % full, inc);

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start+q2-i) % full, -inc);

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start+q2+q2+i) % full, inc);

      GrArc(wid, erase_gc, (width/2)-rad, (height/2)-rad, rad*2, rad*2,

               (start+q2+q2-i) % full, -inc);

      wait_sync ();

      usleep (delay*granularity);

    }

}

#endif

static void

squaretate (int width, int height, int delay, int granularity)

{

  int steps = (((width > height ? width : width) * 2) / granularity);

  int i;

  Bool flip = random() & 1;

#define DRAW() \

      if (flip) { \

        points[0].x = width-points[0].x; \

        points[1].x = width-points[1].x; \

        points[2].x = width-points[2].x; } \

      GrFillPoly (wid, erase_gc, 3, points)

  for (i = 0; i < steps; i++)

    {

      GR_POINT points [3];

      points[0].x = 0;

      points[0].y = 0;

      points[1].x = width;

      points[1].y = 0;

      points[2].x = 0;

      points[2].y = points[0].y + ((i * height) / steps);

      DRAW();

      points[0].x = 0;

      points[0].y = 0;

      points[1].x = 0;

      points[1].y = height;

      points[2].x = ((i * width) / steps);

      points[2].y = height;

      DRAW();

      points[0].x = width;

      points[0].y = height;

      points[1].x = 0;

      points[1].y = height;

      points[2].x = width;

      points[2].y = height - ((i * height) / steps);

      DRAW();

      points[0].x = width;

      points[0].y = height;

      points[1].x = width;

      points[1].y = 0;

      points[2].x = width - ((i * width) / steps);

      points[2].y = 0;

      DRAW();

      wait_sync ();

      if (delay > 0)

        usleep (delay * granularity);

   }

#undef DRAW

}

/* from Frederick Roeber <roeber@netscape.com> */

static void

fizzle (int width, int height, int delay, int granularity)

{

  /* These dimensions must be prime numbers.  They should be roughly the

     square root of the width and height. */

# define BX 31

# define BY 31

# define SIZE (BX*BY)

  int array[SIZE];

  int i, j;

  GR_POINT *skews;

  int nx, ny;

  /* Distribute the numbers [0,SIZE) randomly in the array */

  {

    int indices[SIZE];

    for( i = 0; i < SIZE; i++ ) {

      array[i] = -1;

      indices[i] = i;

    }

    for( i = 0; i < SIZE; i++ ) {

      j = random()%(SIZE-i);

      array[indices[j]] = i;

      indices[j] = indices[SIZE-i-1];

    }

  }

  /* nx, ny are the number of cells across and down, rounded up */

  nx = width  / BX + (0 == (width %BX) ? 0 : 1);

  ny = height / BY + (0 == (height%BY) ? 0 : 1);

  skews = (GR_POINT *)malloc(sizeof(GR_POINT) * (nx*ny));

  if( (GR_POINT *)0 != skews ) {

    for( i = 0; i < nx; i++ ) {

      for( j = 0; j < ny; j++ ) {

        skews[j * nx + i].x = random()%BX;

        skews[j * nx + i].y = random()%BY;

      }

    }

  }

# define SKEWX(cx, cy) (((GR_POINT *)0 == skews)?0:skews[cy*nx + cx].x)

# define SKEWY(cx, cy) (((GR_POINT *)0 == skews)?0:skews[cy*nx + cx].y)

  for( i = 0; i < SIZE; i++ ) {

    int x = array[i] % BX;

    int y = array[i] / BX;

    {

      int iy, cy;

      for( iy = 0, cy = 0; iy < height; iy += BY, cy++ ) {

        int ix, cx;

        for( ix = 0, cx = 0; ix < width; ix += BX, cx++ ) {

          int xx = ix + (SKEWX(cx, cy) + x*((cx%(BX-1))+1))%BX;

          int yy = iy + (SKEWY(cx, cy) + y*((cy%(BY-1))+1))%BY;

          if (xx < width && yy < height)

            GrPoint(wid, erase_gc, xx, yy);

        }

      }

    }

    if( (BX-1) == (i%BX) ) {

      wait_sync ();

      usleep (delay*granularity);

    }

  }

# undef SKEWX

# undef SKEWY

  if( (GR_POINT *)0 != skews ) {

    free(skews);

  }

# undef BX

# undef BY

# undef SIZE

}

/* from Rick Campbell <rick@campbellcentral.org> */

static void

spiral (int width, int height, int delay, int granularity)

{

# define SPIRAL_ERASE_PI_2 (M_PI + M_PI)

# define SPIRAL_ERASE_LOOP_COUNT (10)

# define SPIRAL_ERASE_ARC_COUNT (360.0)

# define SPIRAL_ERASE_ANGLE_INCREMENT (SPIRAL_ERASE_PI_2 /     \

SPIRAL_ERASE_ARC_COUNT)

# define SPIRAL_ERASE_DELAY (0)

  double angle;

  int arc_limit;

  int arc_max_limit;

  int length_step;

  GR_POINT points [3];

  angle = 0.0;

  arc_limit = 1;

  arc_max_limit = (int) (ceil (sqrt ((width * width) + (height * height)))

                         / 2.0);

  length_step = ((arc_max_limit + SPIRAL_ERASE_LOOP_COUNT - 1) /

                 SPIRAL_ERASE_LOOP_COUNT);

  arc_max_limit += length_step;

  points [0].x = width / 2;

  points [0].y = height / 2;

  points [1].x = points [0].x + length_step;

  points [1].y = points [0].y;

  points [2].x = points [1].x;

  points [2].y = points [1].y;

  for (arc_limit = length_step;

       arc_limit < arc_max_limit;

       arc_limit += length_step)

    {

      int arc_length = length_step;

      int length_base = arc_limit;

      for (angle = 0.0; angle < SPIRAL_ERASE_PI_2;

           angle += SPIRAL_ERASE_ANGLE_INCREMENT)

        {

          arc_length = length_base + ((length_step * angle) /

                                      SPIRAL_ERASE_PI_2);

          points [1].x = points [2].x;

          points [1].y = points [2].y;

          points [2].x = points [0].x + (int)(cos (angle) * arc_length);

          points [2].y = points [0].y + (int)(sin (angle) * arc_length);

          GrFillPoly (wid, erase_gc, 3, points);

# if (SPIRAL_ERASE_DELAY != 0)

          usleep (SPIRAL_ERASE_DELAY);

# endif /* (SPIRAL_ERASE_DELAY != 0) */

        }

    }

# undef SPIRAL_ERASE_DELAY

# undef SPIRAL_ERASE_ANGLE_INCREMENT

# undef SPIRAL_ERASE_ARC_COUNT

# undef SPIRAL_ERASE_LOOP_COUNT

# undef SPIRAL_ERASE_PI_2

}

#undef MAX

#undef MIN

#define MAX(a,b) ((a)>(b)?(a):(b))

#define MIN(a,b) ((a)<(b)?(a):(b))

/* from David Bagley <bagleyd@tux.org> */

static void

random_squares(int width, int height, int delay, int granularity)

{

  int randsize = MAX(1, MIN(width, height) / (16 + (random() % 32)));

  int max = (height / randsize + 1) * (width / randsize + 1);

  int *squares = (int *) calloc(max, sizeof (*squares));

  int i;

  int columns = width / randsize + 1;  /* Add an extra for roundoff */

  for (i = 0; i < max; i++)

    squares[i] = i;

  for (i = 0; i < max; i++)

    {

      int t, r;

      t = squares[i];

      r = random() % max;

      squares[i] = squares[r];

      squares[r] = t;

    }

  for (i = 0; i < max; i++)

    {

      GrRect(wid, erase_gc,

                     (squares[i] % columns) * randsize,

                     (squares[i] / columns) * randsize,

                     randsize, randsize);

      wait_sync ();

      if (delay > 0 && ((i % granularity) == 0))

      usleep(delay * granularity);

    }

  free(squares);

}

/* I first saw something like this, albeit in reverse, in an early Tetris

   implementation for the Mac.

    -- Torbjörn Andersson <torbjorn@dev.eurotime.se>

 */

static void

slide_lines (int width, int height, int delay, int granularity)

{

  int slide_old_x, slide_new_x, clear_x;

  int x, y, dx, dy;

  /* This might need some tuning. The idea is to get sensible values no

     matter what the size of the window.

     Everything moves at constant speed. Should it accelerate instead? */

  granularity *= 2;

  dy = MAX (1, height / granularity);

  dx = MAX (1, width / 100);

  for (x = 0; x < width; x += dx)

    {

      for (y = 0; y < height; y += dy)

        {

          if ((y / dy) & 1)

            {

              slide_old_x = x;

              slide_new_x = x + dx;

              clear_x = x;

            }

          else

            {

              slide_old_x = dx;

              slide_new_x = 0;

              clear_x = width - x - dx;

            }

          GrCopyArea (wid, erase_gc, slide_old_x, y, width - x - dx,

                     dy, wid, slide_new_x, y, MWROP_SRCCOPY);

          GrRect (wid, erase_gc, clear_x, y, dx, dy);

        }

      wait_sync ();

      usleep(delay * 3);

    }

}

static Eraser erasers[] = {

  random_lines,

  venetian,

  triple_wipe,

  quad_wipe,

/*  circle_wipe,

  three_circle_wipe, // needs floating point */

  squaretate,

/*  fizzle, // Too slow */

  random_squares,

  spiral,

  slide_lines,

};

void

erase_full_window()

{

  int granularity = 25;

  int delay = 0;

  int mode = random() % countof(erasers);

  (*(erasers[mode])) (WINDOW_WIDTH, WINDOW_HEIGHT, delay, granularity);

  GrRect (wid, erase_gc, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);

  wait_sync ();

}