ndraw.h

NEO SDK是一个跨平台的免费开源图形软件开发包。它支持基本绘图、多种格式图形显示、鼠标操 作、扩展内存和扩充内存的操作、时钟、音频播放、多种字体的汉字及英文显示等等特性；更激动人心的是

         set_vbe_page(page);
         for (k = g_rect_left; k < len; ++k)
         {
            #ifndef NEO_draw_mode_unused
            switch(g_draw_mode)
            {
               case COPY_PUT : d_tmp[k] = color; break;
               case XOR_PUT  : d_tmp[k] = d_tmp[k] ^ color; break;
               case NOT_PUT  : d_tmp[k] = ~d_tmp[k]; break;
               case OR_PUT   : d_tmp[k] = d_tmp[k] | color; break;
               case AND_PUT  : d_tmp[k] = d_tmp[k] & color; break;
            }
            #else
            d_tmp[k] = color;
            #endif
         }
      }
      else
      {
         for (k = g_rect_left; k < length; ++k)
            dot(k + xx, y, color);
      }
      #else
      x1 += 0; y += 0; x2 += 0; color += 0;
      #endif
      return 0;
   }
}

/*绘制一条垂直线的函数*/
void vline(int x, int y1, int y2,int color)
{
   int i;

   if (y1 > y2)
   {
      y1 ^= y2;
      y2 ^= y1;
      y1 ^= y2;
   }

   for (i = y1; i <= y2; ++i)
      dot(x, i, color);
}


#ifndef  NEO_hi_graphics_h_used
void  rect(int x0, int y0, int x1, int y1, int color)
{
   hline(x0, y0, x1, color);
   hline(x0, y1, x1, color);
   vline(x0, y0, y1, color);
   vline(x1, y0, y1, color);
}
#else
void  rect(int x0, int y0, int x1, int y1, int color)
{
   hline(x0, y0, x1, color);
   hline(x0, y1, x1, color);
   vline(x0, y0, y1, color);
   vline(x1, y0, y1, color);

}
#endif


#ifndef  NEO_hi_graphics_h_used
void  tri(int xa, int ya, int xb, int yb, int xc, int yc, int col)
{
   line(xa, ya, xb, yb,col);
   line(xb, yb, xc, yc,col);
   line(xc, yc, xa, ya,col);
}
#else
void  tri(int xa, int ya, int xb, int yb, int xc, int yc, int col)
{
   setcolor(col);
   line(xa, ya, xb, yb);
   line(xb, yb, xc, yc);
   line(xc, yc, xa, ya);
}
#endif


void rectfill(int x1, int y1, int x2, int y2, int color)
{
   int temp;

   if (x1 > x2)
   {
      temp = x1; x1 = x2; x2 = temp;
   }
   if (y1 > y2)
   {
      temp = y1; y1 = y2; y2 = temp;
   }

   for (temp=y1; temp<=y2; ++temp)
   {
      hline(x1, temp, x2, color);
   }
}


void ellipsefill(int center_x, int center_y, int stalk_long,int stalk_short, int fill_color)
{
    double tread = CF_DETAIL/*Detail of circle fill functions*/, fist = 0.0;
    double sit_x, sit_y;
    int dx, dy, x, y, storage_x, storage_y;

    storage_x = storage_y = -1;

    while(fist < 1.5706)
    {
       sit_x = stalk_long * cos(fist) + center_x;
       sit_y = stalk_short * sin(fist) + center_y;

       dx = sit_x * 10;
       dy = sit_y * 10;
    
       if(dx % 10 < 5)
           x = dx / 10;
       else
           x = dx / 10 + 1;

       if(dy % 10 < 5)
           y = dy / 10;
       else
           y = dy / 10 + 1;


       if(x != storage_x || y != storage_y)
       {
         #ifndef  NEO_hi_graphics_h_used
         line(x, y, (center_x<<1) - x, (center_y<<1) - y, fill_color);
         line(x, (center_y<<1) - y, (center_x<<1) - x, y, fill_color);
         #else
         setcolor(fill_color);
         line(x, y, (center_x<<1) - x, (center_y<<1) - y);
         line(x, (center_y<<1) - y, (center_x<<1) - x, y);
         #endif
       }

       storage_x = x;
       storage_y = y;
    
       fist += tread;
    }
}


#ifndef  NEO_hi_graphics_h_used
/*画圆函数，以(c_x, c_y)为中心画一半径为r的圆*/
void circle(int c_x, int c_y, int r, int color)
{
   int x = 0, y = r, d0, d1, d2, direction;
   /*x = 0; y = r;*/
   d0 = (1-r)<<1;

   while (y >= 0)
   {
      dot(c_x + x, c_y + y, color);
      dot(c_x - x, c_y - y, color);
      dot(c_x + x, c_y - y, color);
      dot(c_x - x, c_y + y, color);
      if (d0 < 0)
      {
    d1 = ((d0 + y) << 1) -1;
         if (d1 <= 0) direction = 1;
         else direction = 2;
      }
      else if (d0 > 0)
      {
    d2 = ((d0 - x) << 1) - 1;
         if (d2 <= 0) direction = 2;
         else direction = 3;
      }
      else direction = 2;

      switch(direction)
      {
        case 1 : ++x;
           d0 += (x<<1) + 1;
        break;

        case 2 : ++x;
           --y;
           d0+=(x-y+1)<<1;
        break;

        case 3 : --y;
           d0 += -(y<<1) + 1;
        break;
      }
   }
}
#else
void circle(int c_x, int c_y, int r)
{
   int x = 0, y = r, d0, d1, d2, direction;
   d0 = (1-r)<<1;

   while (y >= 0)
   {
      dot(c_x + x, c_y + y, g_frt_color);
      dot(c_x - x, c_y - y, g_frt_color);
      dot(c_x + x, c_y - y, g_frt_color);
      dot(c_x - x, c_y + y, g_frt_color);
      if (d0 < 0)
      {
         d1 = (d0 + y)<<1 -1;
         if (d1 <= 0) direction = 1;
         else direction = 2;
      }
      else if (d0 > 0)
      {
         d2 = (d0-x)<<1 - 1;
         if (d2 <= 0) direction = 2;
         else direction = 3;
      }
      else direction = 2;

      switch(direction)
      {
        case 1 : ++x;
           d0 += (x<<1) + 1;
        break;

        case 2 : ++x;
           --y;
           d0+=(x-y+1)<<1;
        break;

        case 3 : --y;
           d0 += -(y<<1) + 1;
        break;
      }
   }
}
#endif


/*填充的圆形,使用的是Midpoint算法*/
void circlefill(int x0, int y0, int r, int color)
{
   if (g_color_depth == 8)
   {
      int x;
      int y;
      int deltax;
      int deltay;
      int d;

      x = 0;
      y = r;
      deltax = 3;
      deltay = 2 - (r << 1);
      d = 1 - r;

      while (x <= y)
      {
        hline(x0-x, y0+y, x0+x, color);
        hline(x0-x, y0-y, x0+x, color);
        hline(x0-y, y0-x, x0+y, color);
        hline(x0-y, y0+x, x0+y, color);
        hline(x0-x, y0+y, x0+x, color);

        if(d<0)
        {
            d += deltax;
            deltax += 2;
            x++;
        }
        else
        {
            d += deltax+deltay;
            deltax += 2;
            deltay += 2;
            x++;
            y--;
         }
      }
   }
   else
   {
      ellipsefill(x0, y0, r, r, color);
   }
   
}


#ifndef  NEO_hi_graphics_h_used
/*以(x0,y0)为中心、a和b分别为水平和垂直半轴画一椭圆*/
void ellipse(int x0, int y0, int a, int b, int color)
{
   float d1, d2;
   int x, y;

   x=0; y=b;

   d1 = b * b + a * a * (-b + 0.25);
   dot(x0 + x, y0 + y, color);
   dot(x0 - x, y0 - y, color);
   dot(x0 - x, y0 + y, color);
   dot(x0 + x, y0 - y, color);

   while ((x + 1.0f) * b * b < (y - 0.5f) * a * a)
   {
      if (d1 < 0)
      {
         d1 += (2.0f * x + 3) * b * b;
         ++x;
      }
      else
      {
         d1 += (2.0f * x + 3) * b * b + (-2.0f * y + 2) * a * a;
         ++x; --y;
      }

      dot(x0 + x, y0 + y, color);
      dot(x0 - x, y0 - y, color);
      dot(x0 - x, y0 + y, color);
      dot(x0 + x, y0 - y, color);
   }
   d2 = (x + 0.5f) * b + (y - 1.0f) * a - a * b;
   while (y > 0)
   {
      if (d2 < 0)
      {
         d2 += (2.0f * x + 2) * b * b + (-2.0f * y + 3) * a * a;
         ++x; --y;
      }
      else
      {
         d2 += (-2.0f * y + 3) * a * a;
         --y;
      }

      dot(x0 + x, y0 + y, color);
      dot(x0 - x, y0 - y, color);
      dot(x0 - x, y0 + y, color);
      dot(x0 + x, y0 - y, color);
   }
}
#else
void ellipse(int x0, int y0, int a, int b)
{
   float d1, d2;
   int x, y;

   x=0; y=b;

   d1 = b * b + a * a * (-b + 0.25);
   dot(x0 + x, y0 + y, g_frt_color);
   dot(x0 - x, y0 - y, g_frt_color);
   dot(x0 - x, y0 + y, g_frt_color);
   dot(x0 + x, y0 - y, g_frt_color);

   while ((x + 1.0f) * b * b < (y - 0.5f) * a * a)
   {
      if (d1 < 0)
      {
         d1 += (2.0f * x + 3) * b * b;
         ++x;
      }
      else
      {
         d1 += (2.0f * x + 3) * b * b + (-2.0f * y + 2) * a * a;
         ++x; --y;
      }

      dot(x0 + x, y0 + y, g_frt_color);
      dot(x0 - x, y0 - y, g_frt_color);
      dot(x0 - x, y0 + y, g_frt_color);
      dot(x0 + x, y0 - y, g_frt_color);
   }
   d2 = (x + 0.5f) * b + (y - 1.0f) * a - a * b;
   while (y > 0)
   {
      if (d2 < 0)
      {
         d2 += (2.0f * x + 2) * b * b + (-2.0f * y + 3) * a * a;
         ++x; --y;
      }
      else
      {
         d2 += (-2.0f * y + 3) * a * a;
         --y;
      }

      dot(x0 + x, y0 + y, g_frt_color);
      dot(x0 - x, y0 - y, g_frt_color);
      dot(x0 - x, y0 + y, g_frt_color);
      dot(x0 + x, y0 - y, g_frt_color);
   }
}
#endif


void _dot(int x, int y, int color)
{
   long addr;
   int page;
   if (g_color_depth == 8)
   {
      #ifndef NEO_color_depth_8_unused
      page = (int)((addr = ((long)y + g_sl_offset) * g_screen_h + x) >> 16);

      if (g_cur_vbe_page != page)
      {
         _BX=0;
         _DX=g_cur_vbe_page = page;
         _AX=0x4f05;
         __int__(0x10);
      }
      *(g_videoptr + (unsigned)(addr & 0xffff)) = (unsigned char)color;
      #else
      x = y = color;
      #endif
   }
   else /*if (g_v_mode == 1)*/
   {
      #ifndef NEO_color_depth_16_unused
      int far *videoptr = (int far *)MK_FP(0xa000, 0);
      page = (int)((addr = ((long)y + g_sl_offset) * g_screen_h + x) >> 15);
      if (g_cur_vbe_page != page)
      {
         _BX=0;
         _DX=g_cur_vbe_page = page;
         _AX=0x4f05;
         __int__(0x10);
      }
      *(videoptr + (unsigned)(addr & 0xffff)) = color;
      #else
      x = y = color;
      #endif
   }
}
/*以上均上基本绘图函数*/
#endif


void clear_to_color(int color)
{
   #ifndef NEO_mouse_adv_unused
   if (_mouse_installed && (g_work_surface == g_look_surface))
   {
      scare_mouse();
   }
   #endif

   #ifndef NEO_rect_unused
   rect_store();
   #endif
   screen(0, 0, SCREEN_W, SCREEN_H);
   #ifndef NEO_basic_draw_unused
   rectfill(0, 0, SCREEN_W, SCREEN_H, color);
   #else
   {
      int x, y;
      for (y = 0; y < SCREEN_H; ++y)
         for (x = 0; x < SCREEN_W; ++x)
            dot(x, y, color);
   }
   #endif
   #ifndef NEO_rect_unused
   rect_restore();
   #endif

   #ifndef NEO_mouse_adv_unused
   if (_mouse_installed && (g_work_surface == g_look_surface))
   {
      unscare_mouse();
   }
   #endif
}


void clear(void)
{
   clear_to_color(0);
}


#endif