//gradatePolygon
//showing the function of gradatePolygon()
//A gradated square turns round counter clockwise.
//The colors of the vertices are defined and colors
//of inner points are interpolated.
// T. Kosaka CS TNCT 2001

#include <stdio.h>
#include <math.h>
#include <GL/glut.h>

typedef struct {
    float x;
    float y;
} point_t;

typedef struct {
    float r;
    float g;
    float b;
} color_t;

void setColor(float red,float green,float blue)
{
    glColor3f(red, green, blue);    
}

void setColor(color_t col)
{
    glColor3f(col.r, col.g, col.b); 
}

void drawDot(int x,int y)
{
    glBegin(GL_POINTS);
        glVertex2i(x, y);
    glEnd();
}

void drawLine(int x1, int y1, int x2, int y2)
{
    int dx,dy,dx2,dy2,x,y,inc,c,tmp;
    dx=0<=x2-x1?x2-x1:x1-x2;
    dy=0<=y2-y1?y2-y1:y1-y2;
    dx2=dx<<1;dy2=dy<<1;
    if (dy<=dx) {
        if (x2<x1) {
            tmp=x1;x1=x2;x2=tmp;
            tmp=y1;y1=y2;y2=tmp;
        }
        inc=0<=y2-y1?1:-1;
        x=x1;y=y1;c=-dx;
        drawDot(x,y);
        for (x++;x<=x2;x++) {
            c+=dy2;
            if (0<=c) {c-=dx2;y+=inc;}
            drawDot(x,y);
        }
    } else {
        if (y2<y1) {
            tmp=x1;x1=x2;x2=tmp;
            tmp=y1;y1=y2;y2=tmp;
        }
        inc=0<=x2-x1?1:-1;
        x=x1;y=y1;c=-dy;
        drawDot(x,y);
        for (y++;y<=y2;y++) {
            c+=dx2;
            if (0<=c) {c-=dy2;x+=inc;}
            drawDot(x,y);
        }
    }
}

void drawLine(point_t p1,point_t p2)
{
    drawLine((int)p1.x,(int)p1.y,(int)p2.x,(int)p2.y);
}

//n: number of points
void drawPolyline(point_t pnt[],int n)
{
    int i;
    for (i=0;i<n-1;i++) {
        drawLine(pnt[i],pnt[i+1]);
    }
}

//n: number of vertices
void drawPolygon(point_t pnt[],int n)
{
    int i;
    for (i=0;i<n-1;i++) {
        drawLine(pnt[i],pnt[i+1]);
    }
    drawLine(pnt[n-1],pnt[0]);
}

int interpolateInteger(int p1,int p2,float s1,float s2)
{
    if (s1<0.) s1=0.;
    if (s2<0.) s2=0.;
    if (s1+s2<1.) return p1;
    return (int)((p1*s2+p2*s1)/(s1+s2)+.5);
}

color_t interpolateColor(color_t c1,color_t c2,float s1,float s2)
{
    color_t ret;
    if (s1<0.) s1=0.;
    if (s2<0.) s2=0.;
    if (s1+s2<1.) {
        ret=c1;
    } else {
        ret.r=(1./(s1+s2))*(c1.r*s2+c2.r*s1);
        ret.g=(1./(s1+s2))*(c1.g*s2+c2.g*s1);
        ret.b=(1./(s1+s2))*(c1.b*s2+c2.b*s1);
    }
    return ret;
}

void gradatePolygon(point_t pnt[],color_t col[],int num)
{
    int top,bottom;
    int topleft,topright,bottomleft,bottomright;
    int ymax,ymin,xleft,xright;
    color_t colorleft,colorright,color;
    int i,y,x;
    top=0,bottom=0;
    for(i=0;i<num;i++) {
        if (pnt[top].y<pnt[i].y) top=i;
        if (pnt[i].y<pnt[bottom].y) bottom=i;
    }
    ymax=(int)(pnt[top].y+0.5);
    ymin=(int)(pnt[bottom].y+0.5);
    bottomleft=bottomright=bottom;
    topleft=(bottomleft-1+num)%num;
    topright=(bottomright+1)%num;
    for (y=ymin;y<=ymax;y++) {
        if ((int)(pnt[topleft].y+0.5)<y) {
            bottomleft=topleft;
            topleft=(bottomleft-1+num)%num;
        }
        if ((int)(pnt[topright].y+0.5)<y) {
            bottomright=topright;
            topright=(bottomright+1)%num;
        }
        xleft=interpolateInteger(pnt[topleft].x,pnt[bottomleft].x,pnt[topleft].y-y,y-pnt[bottomleft].y);
        xright=interpolateInteger(pnt[topright].x,pnt[bottomright].x,pnt[topright].y-y,y-pnt[bottomright].y);
        colorleft=interpolateColor(col[topleft],col[bottomleft],pnt[topleft].y-y,y-pnt[bottomleft].y);
        colorright=interpolateColor(col[topright],col[bottomright],pnt[topright].y-y,y-pnt[bottomright].y);
        for (x=xleft;x<=xright;x++) {
            color=interpolateColor(colorleft,colorright,x-xleft,xright-x);
            setColor(color);
            drawDot(x,y);
        }
    }
}

void userdraw(void);

void display(void)
{
    glClear( GL_COLOR_BUFFER_BIT);
    userdraw();
    glutSwapBuffers();
}

void userdraw(void)
{
    static int tick=0;
    point_t pnt[4];
    color_t color[4]={
        {1,0,1},{1,0,0},{0,1,0},{0,0,1}
    };
    pnt[0].x=200.*cos(-(float)tick*.01)+320;
    pnt[0].y=200.*sin(-(float)tick*.01)+240;
    pnt[1].x=200.*cos(-(float)tick*.01+3.1415926535*.5)+320;
    pnt[1].y=200.*sin(-(float)tick*.01+3.1415926535*.5)+240;
    pnt[2].x=200.*cos(-(float)tick*.01+3.1415926535)+320;
    pnt[2].y=200.*sin(-(float)tick*.01+3.1415926535)+240;
    pnt[3].x=200.*cos(-(float)tick*.01+3.1415926535*1.5)+320;
    pnt[3].y=200.*sin(-(float)tick*.01+3.1415926535*1.5)+240;
    gradatePolygon(pnt,color,4);
    tick++;
}

int main(int argc, char **argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB );
    glutInitWindowPosition(100,100);
    glutInitWindowSize(640,480);
    glutCreateWindow ("gradatePolygon");
    glClearColor(0.0, 0.0, 0.0, 0.0);
    gluOrtho2D(0., 640., 0.0, 480.0);
      // Define the dimensions of the Orthographic Viewing Volume
    glutIdleFunc(display);  // idle event call back
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}