_vga.c

数据类型和算法库LEDA 数据类型和算法库LEDA

  register int sy = 1;
  register int dx = x2 - x1;
  register int dy = y2 - y1;
  register int c;
  int i;

  if (dx < 0) 
  { int i = x1;
    x1 = x2;
    x2 = i;
    dx = -dx;
    i = y1;
    y1 = y2;
    y2 = i;
    dy = -dy;
   }

  if (COLOR==0 && LINEWIDTH==1 
               && x1 >= 0 && x1 < 640 && y1 >=0 && y1 < 480 
               && x2 >= 0 && x2 < 640 && y2 >=0 && y2 < 480) 
  { quick_line(x1,y1,x2,y2);
    return;
   }

  if (dx==0)
  { vline(x1,y1,y2,COLOR);
    for (i=1; i<=LINEWIDTH/2; i++)
    { vline(x1-i,y1,y2,COLOR);
      vline(x1+i,y1,y2,COLOR);
     }
    return;
   }

  if (dy < 0)
  { dy = -dy;
    sy = -1;
   }

  if (dx > dy)
  { c = dx / 2;
    put_pixel(x1,y1,COLOR);
    for (i=1; i<=LINEWIDTH/2; i++)
    { put_pixel(x1,y1+i,COLOR);
      put_pixel(x1,y1-i,COLOR);
     }
    while(x1 != x2)
    { x1++;
      c += dy;
      if (c > dx)
      { c -= dx;
        y1 += sy;
       }
      put_pixel(x1,y1,COLOR);
      for (i=1; i<=LINEWIDTH/2; i++)
      { put_pixel(x1,y1+i,COLOR);
        put_pixel(x1,y1-i,COLOR);
       }
    }
  }
  else
  { c = dy / 2;
    put_pixel(x1,y1,COLOR);
    for (i=1; i<=LINEWIDTH/2; i++)
    { put_pixel(x1+i,y1,COLOR);
      put_pixel(x1-i,y1,COLOR);
     }
    while(y1 != y2)
    { y1 += sy;
      c += dx;
      if (c > dy)
      { c -= dy;
        x1++;
       }
      put_pixel(x1,y1,COLOR);
      for (i=1; i<=LINEWIDTH/2; i++)
      { put_pixel(x1+i,y1,COLOR);
        put_pixel(x1-i,y1,COLOR);
       }
    }
  }
}


void save_screen()
{ VIDEO_PTR p;
  VIDEO_PTR q;
  VIDEO_PTR stop = VIDEO_START+80*480;
  for(p=VIDEO_START, q=screen_buf; p != stop; p++,q++) *q = *p;
}

void restore_screen()
{ VIDEO_PTR p;
  VIDEO_PTR q;
  VIDEO_PTR stop = VIDEO_START+80*480;
  for(p=VIDEO_START, q=screen_buf; p != stop; p++,q++) *p = *q;
}


void fill_polygon(n,xcoord,ycoord)
int n, *xcoord, *ycoord;
{ int i,j,m1,m2;
  int minxi = 0;
  int maxxi = 0;
  int minyi = 0;
  int maxyi = 0;
  int minx,maxx,miny,maxy;
  int save_mode  = MODE;
  int save_color = COLOR;
  int save_lw    = LINEWIDTH;

  VIDEO_PTR start1;
  VIDEO_PTR start2;
  VIDEO_PTR video_start = VIDEO_START;
  VIDEO_PTR stop;
  VIDEO_PTR p;
  VIDEO_PTR q;

  VIDEO_START = screen_buf;
  clear_screen();
  MODE  = 0;
  COLOR = 0;
  LINEWIDTH = 1;

  for(i=0; i<n-1; i++) 
     line(xcoord[i],ycoord[i],xcoord[i+1],ycoord[i+1]);

  line(xcoord[0],ycoord[0],xcoord[n-1],ycoord[n-1]);

  for(i=1;i<n;i++) 
  { minxi = (xcoord[i] < xcoord[minxi]) ? i : minxi;
    minyi = (ycoord[i] < ycoord[minyi]) ? i : minyi;
    maxxi = (xcoord[i] > xcoord[maxxi]) ? i : maxxi;
    maxyi = (ycoord[i] > ycoord[maxyi]) ? i : maxyi;
   }

  m1 =  (minxi == 0)   ?  n-1 : minxi-1;
  m2 =  (minxi == n-1) ?  0   : minxi+1;

  flood_fill((xcoord[m1] + xcoord[m2] + xcoord[minxi])/3,
             (ycoord[m1] + ycoord[m2] + ycoord[minxi])/3 );

  MODE  = save_mode;
  COLOR = save_color;
  LINEWIDTH = save_lw;
  VIDEO_START = video_start;

  minx = xcoord[minxi]/8;
  maxx = xcoord[maxxi]/8;
  miny = ycoord[minyi];
  maxy = ycoord[maxyi];


  start1 = screen_buf+80*miny+minx;
  start2 = VIDEO_START+80*miny+minx;

  if (MODE==0)
     if (COLOR==0)
        for(j=miny; j<=maxy; j++) 
        { stop = start2+maxx-minx+1;
          for(q = start1,p=start2; p!=stop; p++,q++) *p &= *q;
          start1 += 80;
          start2 += 80;
         }
     else
        for(j=miny; j<=maxy; j++) 
        { stop = start2+maxx-minx+1;
          for(q = start1,p=start2; p!=stop; p++,q++) *p |= ~(*q);
          start1 += 80;
          start2 += 80;
         }
  else
     if (COLOR==0)
        for(j=miny; j<=maxy; j++) 
        { stop = start2+maxx-minx+1;
          for(q = start1,p=start2; p!=stop; p++,q++) *p ^= ~(*q);
          start1 += 80;
          start2 += 80;
         }
}


void put_text(int x, int y, char *text, int mode)
{
  /* mode = 0 : transparent
     mode = 1 : opaque
   */
  register unsigned char *fp;
  register int i, byte;

  int bgcol = 1-COLOR;

  while (*text)
  { fp = FONT + 16 * (*text&127);
    for (i=0; i<16; i++)
    { byte = *fp++;
      if (byte & 128) put_pixel(x,   y+i, COLOR);
      else if (mode)  put_pixel(x,   y+i, bgcol);
      if (byte & 64)  put_pixel(x+1, y+i, COLOR);
      else if (mode)  put_pixel(x+1, y+i, bgcol);
      if (byte & 32)  put_pixel(x+2, y+i, COLOR);
      else if (mode)  put_pixel(x+2, y+i, bgcol);
      if (byte & 16)  put_pixel(x+3, y+i, COLOR);
      else if (mode)  put_pixel(x+3, y+i, bgcol);
      if (byte & 8)   put_pixel(x+4, y+i, COLOR);
      else if (mode)  put_pixel(x+4, y+i, bgcol);
      if (byte & 4)   put_pixel(x+5, y+i, COLOR);
      else if (mode)  put_pixel(x+5, y+i, bgcol);
      if (byte & 2)   put_pixel(x+6, y+i, COLOR);
      else if (mode)  put_pixel(x+6, y+i, bgcol);
      if (byte & 1)   put_pixel(x+7, y+i, COLOR);
      else if (mode)  put_pixel(x+7, y+i, bgcol);
    }
    text++;
    x += 8;
  }
}


void*  save_box(int left, int top, int right, int bottom) 
{ int i,j;
  VIDEO_PTR start = VIDEO_START + 80*top + left/8;
  register VIDEO_PTR pos;
  unsigned char* p;
  int width  = right/8-left/8 + 1;
  int height = bottom-top + 1;
  int* bitmap = (int*)malloc(4*(sizeof(int))+width*height);
  bitmap[0] = left/8;
  bitmap[1] = top;
  bitmap[2] = width;
  bitmap[3] = height;
  p = (unsigned char*)(bitmap+4);
  for(j=top; j<=bottom; j++) 
  { for(pos = start; pos!=start+width; pos++) *p++ = *pos;
    start += 80;
   }
  return (unsigned char*)bitmap;
}

void  restore_box(void *q) 
{ int i,j;
  VIDEO_PTR start;
  VIDEO_PTR stop;
  register VIDEO_PTR pos;
  int* bitmap = (int*) q;
  unsigned char* p = (unsigned char*)(bitmap+4);
  start = VIDEO_START+80*bitmap[1]+bitmap[0];
  for(j=0; j<bitmap[3]; j++) 
  { stop = start+bitmap[2];
    for(pos = start; pos!=stop; pos++) *pos = *p++;
    start += 80;
   }
}

void box(int x0, int y0, int x1, int y1)
{ int y,i;
  VIDEO_PTR start = VIDEO_START+80*y0;
  VIDEO_PTR stop;
  register VIDEO_PTR pos;
  unsigned char lbyte = 0xFF;
  unsigned char rbyte = 0xFF;
  for(i=7;i>=x0%8;i--) lbyte <<= 1;
  for(i=0;i<=x1%8;i++) rbyte >>= 1;
  if (COLOR==0)
    for(y=y0; y<=y1; y++) 
    { pos = start+x0/8;
      stop = start+x1/8;
      *pos++ &= lbyte;
      while(pos!=stop) *pos++ = 0;
      *pos &= rbyte;
      start += 80;
     }
  else
    for(y=y0; y<=y1; y++) 
    { pos = start+x0/8;
      stop = start+x1/8;
      *pos++ |= ~lbyte;
      while(pos!=stop) *pos++ = 0xFF;
      *pos |= ~rbyte;
      start += 80;
     }
}

void  rectangle(int x0, int y0, int x1, int y1)
{ int left  = x0;
  int right = x1;
  int top   = y0;
  int bottom= y1;
  
  if (x0 > x1)
  { left  = x1;
    right = x0;
   }

  if (y0 > y1)
  { top  = y1;
    bottom = y0;
   }

  line(left, top,     right,top);
  line(left, bottom,  right,bottom);
  line(left, bottom-1,left, top+1);
  line(right,bottom-1,right,top+1);
}


void circle(int x0,int y0,int r)
{ int x = 0;
  int y = r;
  int e = 3-2*y;

  put_pixel(x0,y0+r,COLOR);
  put_pixel(x0,y0-r,COLOR);
  put_pixel(x0+r,y0,COLOR);
  put_pixel(x0-r,y0,COLOR);
  
  for (x=1;x<y;)
    { put_pixel(x0+x,y0+y,COLOR);
      put_pixel(x0+x,y0-y,COLOR);
      put_pixel(x0-x,y0+y,COLOR);
      put_pixel(x0-x,y0-y,COLOR);
      put_pixel(x0+y,y0+x,COLOR);
      put_pixel(x0+y,y0-x,COLOR);
      put_pixel(x0-y,y0+x,COLOR);
      put_pixel(x0-y,y0-x,COLOR);
      x++;
      if (e>=0) { y--; e = e - 4*y; }
      e = e + 4*x + 2;
     }

   put_pixel(x0+x,y0+y,COLOR);
   put_pixel(x0+x,y0-y,COLOR);
   put_pixel(x0-x,y0+y,COLOR);
   put_pixel(x0-x,y0-y,COLOR);
}

#define put_arc_pix(x,y)\
 fi = (float)x/r;\
 if (y<=0) { if (b0<=fi && fi <= a0) put_pixel(x0+x,y0+y,COLOR);}\
 else if (b1>=fi && fi >= a1) put_pixel(x0+x,y0+y,COLOR);\
  
void arc(int x0,int y0,int r, double a, double b)
{ int x = 0;
  int y = r;
  int e = 3-2*y;
  float fi;
  float a0 = -1,b0 = 1,a1 = 1,b1 = -1;

  if (a<=M_PI) 
  { a0 = cos(a);
    if (b<=M_PI) 
      b0 = cos(b);
    else
      { b0 = -1;
        a1= -1;
        b1 = cos(b);
       }
   }
  else
  { a1 = cos(a);
    if (b>=M_PI) 
      b1 = cos(b);
    else
      { b1 = 1;
        a0 = 1;
        b0 = cos(b);
       }
   }


  put_arc_pix(0,r);
  put_arc_pix(0,-r);
  put_arc_pix(r,0);
  put_arc_pix(-r,0);
  
  for (x=1;x<y;)
    { put_arc_pix(x,y);
      put_arc_pix(x,-y);
      put_arc_pix(-x,y);
      put_arc_pix(-x,-y);
      put_arc_pix(y,x);
      put_arc_pix(y,-x);
      put_arc_pix(-y,x);
      put_arc_pix(-y,-x);
      x++;
      if (e>=0) { y--; e = e - 4*y; }
      e = e + 4*x + 2;
     }

   put_arc_pix(x,y);
   put_arc_pix(x,-y);
   put_arc_pix(-x,y);
   put_arc_pix(-x,-y);
}


void fill_circle(x0,y0,r)
int x0,y0;
int r;
{ int x = 1;
  int y = r;
  int e = 3-2*r;

  vline(x0,y0-y,y0+y,COLOR);

  while (x<=y)
  { vline(x0+x,y0-y,y0+y,COLOR);
    vline(x0-x,y0-y,y0+y,COLOR);

    if (x<y && e>=0) 
    { vline(x0+y,y0-x,y0+x,COLOR);
      vline(x0-y,y0-x,y0+x,COLOR);
      y--; 
      e = e - 4*y; 
     }
    x++;
    e = e + 4*x + 2;
   }
}