OpenGL画线画圆画多边形

算法是midpoint drawing algorithm，谁想的我也不知道...

画线：按l，用鼠标点两个点；

画圆：按o，用鼠标点一个圆心拉成一个圆；

画多边形：按p，就跟画线差不多，最后右键闭合；

清屏：按c；

重画：按c后按r，redraw，需要用链表保存每个图形；

ps:在vs下运行.

又修改了一下
// Computer Graphics: Lab1
#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <gl/glut.h>

using namespace std;
int height, width;
static int xOrg = 0, yOrg = 0;
// Max number of lines for drawing: 100
const int max_line=100;
// Max number of polygons for drawing: 20
const int max_polygon=20;
// Max number of circles for drawing: 20
const int max_circle=20;


struct line_structure
{
    int x0,x1,y0,y1;
};
struct line_data
{
    int x,y;
    line_data* next;
};
struct center_data
{
    int c_x, c_y;
};

struct poly_point
{
    int x;
    int y;
}pp[max_line];

line_structure line[max_line];
line_data line_start[max_line];
line_data polygon_start[max_polygon];
line_data circle_start[max_circle];
center_data center[max_circle];
//line_data* lcp;
line_data* temp;

int points[3];

int key_line=1;

int num_lines=0; //这个全局变量好像有点问题，不知道为什么值会变
int num_polygon=0;
int num_circle=0;
int count_num_line=0;

bool connected=false;
bool first_point=true;
int count_line_points=0;
int count_poly_point=0;

void drawDot(int x, int y, float r, float g, float b);
void Mymouse_Dot(int button, int state, int x, int y);
void Myhouse_Line(int button, int state, int x, int y);
void Mymouse_Polygon(int button, int state, int x, int y);
void Mymouse_Circle(int button, int state, int x, int y);
void drawLine1(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine2(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine3(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine4(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawCircle(int radius, int center_x, int center_y);
void CirclePoints(int x, int y, int center_x, int center_y);
void redraw();
void myKeyboard(unsigned char key, int x, int y);
void clear();
void displayFunc(void);
void DrawLines_4(int x1, int y1, int x2, int y2);

void DrawLines_4(int x1, int y1, int x2, int y2) //判断画哪一种线
{
    if(x1 >= x2)
    {
        if(y1 >= y2)
        {
            swap(x1, x2);
            swap(y1, y2);
            if((y2-y1) >= (x2-x1))            
                drawLine2(x1, y1, x2, y2, 1);    
            else
                drawLine1(x1, y1, x2, y2, 1);
        }
        else
        {
            if((y2-y1) >= (x1-x2))
                drawLine3(x1, y1, x2, y2, 1);
            else
                drawLine4(x2, y2, x1, y1, 1);
        }                
    }
    else
    {
        if(y2 >= y1)
        {
            if((y2-y1) <= (x2-x1))
                drawLine1(x1, y1, x2, y2, 1);
            else
                drawLine2(x1, y1, x2, y2, 1);
        }
        else
        {
            if((y1-y2) <= (x2-x1))
                drawLine4(x1, y1, x2, y2, 1);
            else
                drawLine3(x2, y2, x1, y1, 1);
        }
    }
    
    glFlush();
}

// Draw 8 points
void CirclePoints(int x, int y, int center_x, int center_y)
{
    drawDot(x+center_x, y+center_y, 10.0, 0.0, 0.0);
    drawDot(x+center_x, -y+center_y, 10.0, 0.0, 0.0);
    drawDot(-x+center_x, y+center_y, 10.0, 0.0, 0.0); 
    drawDot(-x+center_x, -y+center_y, 10.0, 0.0, 0.0); 
    drawDot(y+center_x, x+center_y, 10.0, 0.0, 0.0); 
    drawDot(y+center_x, -x+center_y, 10.0, 0.0, 0.0); 
    drawDot(-y+center_x, x+center_y, 10.0, 0.0, 0.0); 
    drawDot(-y+center_x, -x+center_y, 10.0, 0.0, 0.0); 
}

// Draw a circle
void drawCircle(int radius, int center_x, int center_y)
{
    cout << "Drawing Circle!!!" << endl;
    int x = 0; //初始值必须为0
    int y = radius;
    
    center_data center_point; //储存圆心
    center_point.c_x = xOrg;
    center_point.c_y = yOrg;
    center[num_circle] = center_point;
    
    circle_start[num_circle].x = x; //储存起点
    circle_start[num_circle].y = y;
    circle_start[num_circle].next = NULL;
    line_data *tmp = &circle_start[num_circle];
    num_circle++;

    int d = 1 - radius;
    int IncE = 3;
    int IncSE = -2 * radius + 5;
    while(x < y)
    {
        if(d < 0)
        {
            d += IncE;
            x++;
            IncE += 2;
            IncSE += 2;
        }
        else
        {
            d += IncSE;
            x++;
            y--;
            IncE += 2;
            IncSE += 4;
        }
        CirclePoints(x, y, center_x, center_y);
        
        line_data *add = new line_data;
        add->x = x;
        add->y = y;
        add->next = NULL;
        tmp->next = add;
        tmp = add;
    }
}

// Mouse control for circle drawing
void Mymouse_Circle(int button, int state, int x, int y)                                 //Circle
{
    if(num_circle > max_circle)
        return ;
    int radius = 0;
    if (state == GLUT_DOWN) {
        cout << "	button is down" << endl;
        if (button == GLUT_LEFT_BUTTON)
        {
            drawDot(x, y, 0.0, 10.0, 0.0); 
            glFlush();        
        }
        xOrg = x;
        yOrg = y;
        
    }
    else if (state == GLUT_UP) {
        cout << "	button is up" << endl;
        if (button == GLUT_LEFT_BUTTON)
        {
            drawDot(x, y, 0.0, 10.0, 0.0); 
            glFlush();    
            radius = (int)sqrt((xOrg-x)*(xOrg-x) + (yOrg-y)*(yOrg-y));
            drawCircle(radius, xOrg, yOrg);
            glFlush(); //必须要加
        }
    }
    cout << "		 Previous location: (" << xOrg << " , " << yOrg << ")" << endl;
    cout << "		 New location: (" << x << " , " << y << ")" << endl;

    /*
    cout << "x_down: " << xOrg << endl;
    cout << "y_down: " << yOrg << endl;
    cout << "x_up: " << x_up << endl;
    cout << "y_up: " << y_up << endl;
    cout << "radius: " << radius << endl;
    */
}

// Clear screen
void clear()
{
    glClearColor(0.0,0.0,0.0,0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glFlush();
}

// Mouse control for polygon drawing
void Mymouse_Polygon(int button, int state, int x, int y)                             //Polygon
{
    cout << count_poly_point << endl;
    if(num_polygon > max_polygon)
        return ;
    if (state == GLUT_DOWN) {
        cout << "	button is down" << endl;
        if (button == GLUT_LEFT_BUTTON)
        {
            drawDot(x, y, 0.0, 10.0, 0.0); 
            glFlush();
            if(count_poly_point < 1)
            {
                polygon_start[num_polygon].x = x;
                polygon_start[num_polygon].y = y;
                polygon_start[num_polygon].next = NULL;
            
                temp = &polygon_start[num_polygon];

                poly_point p;
                p.x = x;
                p.y = height - y; //转换坐标
                pp[count_poly_point] = p;
            }
            else
            {    
                int x1 = pp[count_poly_point-1].x;
                int y1 = pp[count_poly_point-1].y;
                int x2 = x;
                int y2 = height - y;
                pp[count_poly_point].x = x2;
                pp[count_poly_point].y = y2;
                

                DrawLines_4(x1, y1, x2, y2);
            }
            count_poly_point++;
        }
        
        
        if (button == GLUT_RIGHT_BUTTON)
        {
            int x1 = pp[0].x;
            int y1 = pp[0].y;
            int x2 = pp[count_poly_point-1].x;
            int y2 = pp[count_poly_point-1].y;
            DrawLines_4(x1, y1, x2, y2);
            num_polygon++;
            count_poly_point = 0;
        }
    }
}

// Redraw all objects stored 
void redraw()                                                                               //Redraw
{
    int i;
    line_data* rd_line;
    line_data* rd_polygon;
    line_data* rd_circle;

    for (i=0;i<count_num_line;i++)
    {
        rd_line=&line_start[i];
        drawDot(rd_line->x,rd_line->y,0,1,0);
        do
        {
            rd_line=rd_line->next;
            drawDot(rd_line->x,rd_line->y,0,1,0);
        } while (rd_line->next!=NULL);
    }
    
    for (i=0;i<num_polygon;i++)
    {
        rd_polygon=&polygon_start[i];
        drawDot(rd_polygon->x,rd_polygon->y,0,1,0);
        do
        {
            rd_polygon=rd_polygon->next;
            drawDot(rd_polygon->x,rd_polygon->y,0,1,0);
        } while (rd_polygon->next!=NULL);
    }
    
    for (i=0;i<num_circle;i++)
    {
        rd_circle=&circle_start[i];
        CirclePoints(rd_circle->x,rd_circle->y,center[i].c_x,center[i].c_y);        
        do
        {
            rd_circle=rd_circle->next;
            CirclePoints(rd_circle->x,rd_circle->y,center[i].c_x,center[i].c_y);
        } while (rd_circle->next!=NULL);
    }
    glFlush();
}

// draw a dot at location with integer coordinates (x,y), and with color (r,g,b)
void drawDot(int x, int y, float r, float g, float b) 
{
    glBegin(GL_POINTS);
  
    // set the color of dot
    glColor3f(r, g, b);
  
    // invert height because the opengl origin is at top-left instead of bottom-left
    glVertex2i(x , height - y);
  
    glEnd();
}

// Mouse callback function
void Mymouse_Dot(int button, int state, int x, int y)                                            //Dot
{
    if (state == GLUT_DOWN) {
        cout << "	button is down" << endl;
        if (button == GLUT_LEFT_BUTTON) {
            drawDot(x, y, 0.0, 10.0, 0.0);
            glFlush();
        }
        else if (button == GLUT_MIDDLE_BUTTON) {
            drawDot(x, y, 0.0, 1.0, 0.0);
            glFlush();
        }
        else if (button == GLUT_RIGHT_BUTTON) {
            drawDot(x, y, 0.0, 0.0, 1.0);
            glFlush();
        }
        xOrg = x;
        yOrg = y;
    }
    else if (state == GLUT_UP) {
        cout << "	button is up" << endl;
        if (button == GLUT_LEFT_BUTTON) {    
            drawDot(x, y, 0.0, 10.0, 0.0);
            glFlush();
        }
        else if (button == GLUT_MIDDLE_BUTTON) {
            drawDot(x, y, 0.0, 0.5, 0.0);
            glFlush();
        }
        else if (button == GLUT_RIGHT_BUTTON) {
            drawDot(x, y, 0.0, 0.0, 0.5);
            glFlush();
        }
    }
    cout << "		 Previous location: (" << xOrg << " , " << yOrg << ")" << endl;
    cout << "		 New location: (" << x << " , " << y << ")" << endl;
}



// Mouse control for line drawing 
void Mymouse_Line(int button, int state, int x, int y)                                    //Line
{
    if(count_num_line > max_line)
        return ;
    if (state == GLUT_DOWN) {
        cout << "	button is down" << endl;
        if (button == GLUT_LEFT_BUTTON)
        {
            drawDot(x, y, 0.0, 10.0, 0.0); 
            glFlush();        
        }
        xOrg = x;
        yOrg = height - y; //转换坐标
        
        if(count_line_points < 4)
        {
            points[count_line_points++] = xOrg;
            points[count_line_points++] = yOrg;
        }
        if(count_line_points == 4)
        {
            count_line_points = 0;
            int x1 = points[0];
            int y1 = points[1];
            int x2 = points[2];
            int y2 = points[3];
            
            line_start[count_num_line].x = x;
            line_start[count_num_line].y = y;
            line_start[count_num_line].next = NULL;
            temp = &line_start[count_num_line];

            DrawLines_4(x1, y1, x2, y2);

            count_num_line++;

            glFlush();
        }
        
    }
    cout << "		 Previous location: (" << xOrg << " , " << yOrg << ")" << endl;
    cout << "		 New location: (" << x << " , " << y << ")" << endl;
}

// Draw line for dx>0 and dy>0
void drawLine1(int x1, int y1, int x2, int y2, bool xy_interchange) //0-45度
{
    cout << "Drawing Line1!" << endl;
    int x = x1;
    int y = y1;    

    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(x, height-y, 0.0, 10.0, 0.0);
        
        line_data *add = new line_data;
        add->x = x;
        add->y = height-y;
        add->next = NULL;
        temp->next = add;
        temp = add;
    }
}

// Draw line for dx>0 and dy<0
void drawLine2(int x1, int y1, int x2, int y2, bool xy_interchange) //45-90度
{
    cout << "Drawing Line2!" << endl;
    //转换为0-45度的情况
    swap(x2, y2);
    swap(x1, y1);

    int x = x1;
    int y = y1;
    
    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(y, height-x, 0.0, 10.0, 0.0);

        line_data *add = new line_data;
        add->x = y;
        add->y = height-x;
        add->next = NULL;
        temp->next = add;
        temp = add;    
    }    
}

// Draw line for dx<0 and dy>0
void drawLine3(int x1, int y1, int x2, int y2, bool xy_interchange) //90-135度
{
    cout << "Drawing Line3!" << endl;
    swap(x2, y2);
    swap(x1, y1);
    y1 = -y1;
    y2 = -y2;
    int x = x1;
    int y = y1;

    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(-y, height-x, 0.0, 10.0, 0.0);

        line_data *add = new line_data;
        add->x = -y;
        add->y = height-x;
        add->next = NULL;
        temp->next = add;
        temp = add;
    }
}

// Draw line for dx<0 and dy>0
void drawLine4(int x1, int y1, int x2, int y2, bool xy_interchange) //135-180度
{
    cout << "Drawing Line4!" << endl;
    y1 = -y1;
    y2 = -y2;
    int x = x1;
    int y = y1;
    
    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(x, height+y, 0.0, 10.0, 0.0);

        line_data *add = new line_data;
        add->x = x;
        add->y = height+y;
        add->next = NULL;
        temp->next = add;
        temp = add;
    }
}

// Keyboard callback function
void myKeyboard(unsigned char key, int x, int y) 
{
    switch(key) {
    // Draw dots with 'd' or 'D'
    case 'd':
    case 'D':
        cout << "press key: " << 'd' << endl;
          glutMouseFunc(Mymouse_Dot);
          break;
    // Draw lines with 'l' or 'L'
    case 'l':
    case 'L':
        cout << "press key: " << 'l' << endl;
        glutMouseFunc(Mymouse_Line);
        break;
    // Draw polygons with 'p' or 'P'
    case 'p':
    case 'P':
        cout << "press key: " << 'p' << endl;
        glutMouseFunc(Mymouse_Polygon);
        break;
    // Draw circle with 'c' or 'C'
    case 'o':
    case 'O':
        cout << "press key: " << 'o' << endl;
        glutMouseFunc(Mymouse_Circle);
        break;
    // Redraw all with 'r' or 'R'
    case 'r':
    case 'R':
        cout << "press key: " << 'r' << endl;
        redraw();
        break;
    // Clear screen with 'c' or 'C'
    case 'c':
    case 'C':
        cout << "press key: " << 'c' << endl;
        clear();
        break;
    // Quit with 'q' or 'Q'
    case 'q':
    case 'Q':
        cout << "press key: " << 'q' << endl;
        exit(0);
        break;
    }
}

// Display function
void displayFunc(void){
    // clear the entire window to the background color
    glClear(GL_COLOR_BUFFER_BIT); 
    glClearColor(0.0, 0.0, 0.0, 0.0); 

    // draw the contents!!! Iterate your object's data structure!

    // flush the queue to actually paint the dots on the opengl window
    glFlush();
}

// Main
void main(int ac, char** av) {

    cout << "Hello Glut!" << endl;
    
    int winSizeX, winSizeY;
  
    if(ac == 3) {
    winSizeX = atoi(av[1]);
    winSizeY = atoi(av[2]);
    }
    else { // default window size
    winSizeX = 800;
    winSizeY = 600;
    }

    width  = winSizeX;
    height = winSizeY;

    // initialize OpenGL utility toolkit (glut)
    glutInit(&ac, av);

    // single disply and RGB color mapping
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set display mode
    glutInitWindowSize(winSizeX, winSizeY);      // set window size
    glutInitWindowPosition(400, 100);                // set window position on screen
    glutCreateWindow("Lab1 Window");       // set window title
  
    // set up the mouse and keyboard callback functions
    glutKeyboardFunc(myKeyboard); // register the keyboard action function

    // displayFunc is called whenever there is a need to redisplay the window,
    // e.g., when the window is exposed from under another window or when the window is de-iconified
    glutDisplayFunc(displayFunc); // register the redraw function

    // set background color
    glClearColor(0.0, 0.0, 0.0, 0.0);     // set the background to black
    glClear(GL_COLOR_BUFFER_BIT); // clear the buffer

    // misc setup
    glMatrixMode(GL_PROJECTION);  // setup coordinate system
    glLoadIdentity();
    gluOrtho2D(0, winSizeX, 0, winSizeY);
    glShadeModel(GL_FLAT);
    glFlush();
    glutMainLoop();
}