gpcdraw.c

使用键盘上的上、下、左、右四个按键

    do {
        gpcDrawPoint((S16)(x0+x), (S16)(y0+y));
        gpcDrawPoint((S16)(x0-x), (S16)(y0+y));
        gpcDrawPoint((S16)(x0+x), (S16)(y0-y));
        gpcDrawPoint((S16)(x0-x), (S16)(y0-y));
        if (d < 0) {
            x++;
            dx += two_bsqr;
            d  += dx;
        }
        y--;
        dy -= two_asqr;
        d  += (asqr-dy);
    } while (y>=0);
    
}

//-------------------------------------------------------------------------
//    gpcFillEllipse()
//
//  Fill Ellipse in the left, top, right, bottom.
//
//  Parameters:
//      left    - Position left of Ellipse.
//      top     - Position top of Ellipse.
//      right   - Position right of Ellipse.
//      bottom  - Position bottom of Ellipse.
//    Returns:
//      GPC_ERR_OK
//-------------------------------------------------------------------------
U16 gpcFillEllipse(S16 left, S16 top, S16 right, S16 bottom)
{
    S16 x0=(right+left)>>1;
    S16 y0=(bottom+top)>>1;

    S16 a0 = abs(right - x0);
    S16 b0 = abs(bottom - y0);

    FillEllipse (x0,y0,a0,b0);

    return GPC_ERR_OK;

}

//-------------------------------------------------------------------------
//    FillEllipse()
//
//  Fill Ellipse in the x0, y0, a0, b0.
//
//  Parameters:
//      x0    - Position x0 of Ellipse.
//      y0    - Position y0 of Ellipse.
//      a0    - Position width of Ellipse.
//      b0    - Position height of Ellipse.
//    Returns:
//      GPC_ERR_OK
//-------------------------------------------------------------------------
static void FillEllipse (S16 x0, S16 y0, S16 a0, S16 b0 )
{

    S16 x = 0;
    S16 y = b0;

    S16 a = a0;
    S16 b = b0;

    S16 asqr = a * a;
    S16 two_asqr = asqr<<1;
    S16 bsqr = b * b;
    S16 two_bsqr = bsqr<<1;

    S32 d, dx, dy;

    d = bsqr - asqr * b + (asqr >> 2);

    dx = 0;
    dy = (long)two_asqr * b;

    gpcGC.GCLineStyle = GPC_SOLID_LINE;

    gpcDrawLine(x0, (S16)(y0-b0), x0, (S16)(y0+b0));
    gpcDrawLine((S16)(x0-a0), y0, (S16)(x0+a0), y0);

    do {
        gpcDrawLine((S16)(x0+x), (S16)(y0+y), (S16)(x0+x), (S16)(y0-y));
        gpcDrawLine((S16)(x0-x), (S16)(y0+y), (S16)(x0-x), (S16)(y0-y));
        if (d > 0) {
            y--;
            dy -= two_asqr;
            d  -= dy;
        }
        x++;
        dx += two_bsqr;
        d  += (bsqr+dx);
    } while (dx<dy);

    d += (3*(asqr-bsqr)/2 - (dx+dy))/2;

    do {
        gpcDrawLine((S16)(x0+x), (S16)(y0+y), (S16)(x0+x), (S16)(y0-y));
        gpcDrawLine((S16)(x0-x), (S16)(y0+y), (S16)(x0-x), (S16)(y0-y));
        if (d < 0) {
            x++;
            dx += two_bsqr;
            d  += dx;
        }
        y--;
        dy -= two_asqr;
        d  += (asqr-dy);
    } while (y>=0);

}

//-------------------------------------------------------------------------
//    gpcDrawCircle()
//
//  Draw Bresenham's Circle Generation Algorithm.
//
//  Parameters:
//      x0    - Position x0 of Circle.
//      y0    - Position y0 of Circle.
//      r     - Radius of Circle.
//    Returns:
//      GPC_ERR_OK
//-------------------------------------------------------------------------
U16 gpcDrawCircle(S16 x0, S16 y0, S16 r)
{
    S16 x, y, d;

    // 2000.06.28 add by shin: check radius <= 0
    if(r <= 0) {
        return GPC_ERR_FAILED;
    }
    x = x0;
    y = y0+r;
    d = 3-2*r;

    do {
        gpcDrawPoint (x, y); 
        gpcDrawPoint (x, (S16)(y0-(y-y0)));
        gpcDrawPoint ((S16)((x0-(x-x0))), y);
        gpcDrawPoint ((S16)((x0-(x-x0))), (S16)(y0-(y-y0)));

        gpcDrawPoint ((S16)(x0+(y-y0)), (S16)(y0+(x-x0)));
        gpcDrawPoint ((S16)(x0+(y-y0)), (S16)(y0-(x-x0)));
        gpcDrawPoint ((S16)(x0-(y-y0)), (S16)(y0+(x-x0)));
        gpcDrawPoint ((S16)(x0-(y-y0)), (S16)(y0-(x-x0)));

        if (d<0) {
            d = d+((x-x0)<<2)+6;
        } else {
            d = d+(((x-x0)-(y-y0))<<2)+10;
            y--;
        }

        x++;

    } while((x-x0)<=(y-y0));

    return GPC_ERR_OK;
}

//-------------------------------------------------------------------------
//    gpcFillCircle()
//
//  Fill Bresenham's Circle Generation Algorithm.
//
//  Parameters:
//      x0    - Position x0 of Circle.
//      y0    - Position y0 of Circle.
//      r     - Radius of Circle.
//    Returns:
//      GPC_ERR_OK
//-------------------------------------------------------------------------
U16 gpcFillCircle(S16 x0, S16 y0, S16 r)
{
    S16 x, y, d;

    // 2000.06.28 add by shin: check radius <= 0
    if(r <= 0) {
        return GPC_ERR_FAILED;
    }
    x = x0;
    y = y0+r;
    d = 3-2*r;

    gpcGC.GCLineStyle = GPC_SOLID_LINE;

    do {
        gpcDrawLine (x, (S16)(y0-(y-y0)), x, y); 
        gpcDrawLine ((S16)(x0-(x-x0)), (S16)(y0-(y-y0)), (S16)(x0-(x-x0)), y);

        gpcDrawLine ((S16)(x0-(y-y0)), (S16)(y0-(x-x0)), (S16)(x0+(y-y0)), (S16)(y0-(x-x0)));
        gpcDrawLine ((S16)(x0-(y-y0)), (S16)(y0+(x-x0)), (S16)(x0+(y-y0)), (S16)(y0+(x-x0)));

        if (d<0) {
            d = d+((x-x0)<<2)+6;
        } else {
            d = d+(((x-x0)-(y-y0))<<2)+10;
            y--;
        }

        x++;

    } while((x-x0)<=(y-y0));

    return GPC_ERR_OK;
}

//-------------------------------------------------------------------------
//    gpcDrawArc()
//
//  Draw Bresenham's Arc Generation Algorithm.
//
//  Parameters:
//      x0     - Position x0 of Arc.
//      y0     - Position y0 of Arc.
//      r      - Radius of Arc.
//      angle1 - Start Angle of Arc.
//      angle2 - End Angle of Arc.
//    Returns:
//      GPC_ERR_OK
//-------------------------------------------------------------------------
U16 gpcDrawArc(S16 x0, S16 y0, S16 r, S16 angle1, S16 angle2)
{
    S16 x, y, d;
    S16 iDiff;
    S16 iLimit;
    S16 iStartAngle1=0, iStartAngle2=0, iStartAngle3=0, iStartAngle4=0;
    S16 iEndAngle1=0, iEndAngle2=0, iEndAngle3=0, iEndAngle4=0;
    double dfCheck;

    // 2000.06.28 add by shin: check radius <= 0
    if(r <= 0) {
        return GPC_ERR_FAILED;
    }

    // Check angle1 < 0, angle2 < 0 
    if(angle1 < 0 || angle2 < 0) {
        return GPC_ERR_FAILED;
    }

    // Check angle1 > angle2
    if(angle1 > angle2) {
        return GPC_ERR_FAILED;
    }

    // Check No.1 of Arc
    if(angle1 >= 0 && angle1 <= 90){
        iStartAngle1 = angle1;
        if(angle2 >= 0 && angle2 <= 90) {
            iEndAngle1 = angle2;
        }
        else {
            iEndAngle1 = 90;
        }
    }

    // Check No.2 of Arc
    if(angle1 >= 0 && angle1 < 180) {
        if(angle1 >= 90) {
            iStartAngle2 = angle1%90;
        }
        else {
            iStartAngle2 = 0;
        }
        if(angle2 > 90 && angle2 < 180) {
            iEndAngle2 = angle2%90;
        }
        else {
            if(angle2 >= 180) { 
                iEndAngle2 = 90;
            }
            else {
                iEndAngle2 = 0;
            }
        }
    }

    // Check No.3 of Arc
    if((angle1 >= 0) && (angle1 < 270)){
        if(angle1 >= 180) {
            iStartAngle3 = angle1%90;
        }
        else {
            iStartAngle3 = 0;
        }
        if(angle2 > 180 && angle2 < 270) {
            iEndAngle3 = angle2%90;
        }
        else {
            if(angle2 >= 270) { 
                iEndAngle3 = 90;
            }
            else {
                iEndAngle3 = 0;
            }
        }
    }

    // Check No.4 of Arc
    if((angle1 >= 0) && (angle1 < 360)){
        if(angle1 >= 270) {
            iStartAngle4 = angle1%90;
        }
        else {
            iStartAngle4 = 0;
        }
        if(angle2 > 270 && angle2 < 360) {
            iEndAngle4 = angle2%90;
        }
        else {
            if(angle2 >= 360) { 
                if(angle2 == 360) {
                }
                iEndAngle4 = 90;
            }
            else {
                iEndAngle4 = 0;
            }
        }
    }

    x = 0;
    y = r;
    d = 2-2*r;
    iLimit = 0;

    do {
        // Draw No.1 of Arc
        if(angle1>=0 && angle1<=90){
            if(iLimit >= ((r/1.414)*((90-iEndAngle1)/45.))){
                if(iLimit <= ((r/1.414)*((90-iStartAngle1)/45.) + 1)){
                    gpcDrawPoint ((S16)(x0 + x), (S16)(y0 - y)); // 1
                }
            }
        }

        // Draw No.2 of Arc
        if((angle1>=0 && angle1<180) && (angle2 >= 90)){
            if(iLimit >= ((r/1.414)*((iStartAngle2)/45.))){
                if(iLimit <= (r/1.414)*((iEndAngle2)/45.)){
                    gpcDrawPoint ((S16)(x0 - x) ,(S16)(y0 - y)); // 2
                }
            }
        }

        // Draw No.3 of Arc
        if((angle1>=0 && angle1<270) && (angle2 >= 180)){
            if(iLimit >= ((r/1.414)*((90-iEndAngle3)/45.))){
                if(iLimit <= ((r/1.414)*((90-iStartAngle3)/45.) + 1)){
                    gpcDrawPoint ((S16)(x0 - x) ,(S16)(y0 + y)); // 3
                }
            }
        }

        // Draw No.4 of Arc
        if((angle1>=0 && angle1<360) && (angle2 >= 270)){
            if(iLimit >= ((r/1.414)*((iStartAngle4)/45.))){
                if(iLimit <= (r/1.414)*((iEndAngle4)/45.)){
                    gpcDrawPoint ((S16)(x0 + x) ,(S16)(y0 + y)); // 4
                }
            }
        }

        if (d<0) {
            iDiff = (2*d) + (2*y) - 1;
            if (iDiff <= 0) {
                x++;
                d = d + (2*x) + 1;
            }
            else {
                x++;
                y--;
                d = d + (2*x) - (2*y) + 2;
            }
        } else {
            if(d>0) {
                iDiff = (2*d) - (2*x) - 1;
                if (iDiff > 0) {
                    y--;
                    d = d - (2*y) + 1;
                }
                else { // iDiff <= 0
                    x++;
                    y--;
                    d = d + (2*x) - (2*y) + 2;
                }
            }
            else { // d == 0
                    x++;
                    y--;
                    d = d + (2*x) - (2*y) + 2;
            }
        }
        iLimit++;
        dfCheck = (r/1.414)*2 + 1;

    } while(dfCheck > (double)iLimit);

    return GPC_ERR_OK;
}

//----------------------------- The End of the File ----------------------------