OPenGL 裁剪窗口

/*************************************************************
     裁剪窗口
     
*************************************************************/


#include <GL/glut.h>
#include<cstdio>
#include<cmath>

#define ymin -300
#define ymax 300
#define xmin -400
#define xmax 400

struct point 
{
    int x;
    int y;
};

typedef enum
{
    L,R,B,T
}BD;

point s,e;
point in[100],out[100];
int len=0;


void init()
{
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);                 //什么单缓存的东西，现在不懂什么意思，就当通用条件
    glutInitWindowPosition(0, 0);                                //图片出现的位置
    glutInitWindowSize(400, 300);                                //图片的长和宽
    glutCreateWindow("pb-图形学题1");                            //图片的名字

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    gluOrtho2D(-1000, 1000, -1000, 1000); 

    glRectf(-0.5f, -0.5f, 0.5f, 0.5f); 
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 0.0, 0.0);  
    
    printf("请输入裁剪直线的起点和终点:
");
    scanf("%d%d%d%d",&s.x,&s.y,&e.x,&e.y);
    if (s.x>e.x)
    {
        point temp;
        temp=s;
        s=e;
        e=temp;
    }
    printf("请输入多边形的端点");
    while (~scanf("%d%d",&in[len].x,&in[len++].y));
    len--;
    in[len]=in[0];

}


void setPixel (GLint x,GLint y,GLint nx,GLint ny)               //描点函数，表示从x,y到nx,ny的矩形全部涂色
{
    glBegin(GL_LINES);
       glVertex2i(x, y);
       glVertex2i(nx,ny);
    glEnd();
}

bool insert(point s,BD b)                                //判断短知否在边界内
{
    switch(b)
    {
        case L:
            if (s.x<=xmin) return false;
            break;
        case R:
            if (s.x>=xmax) return false;
            break;
        case B:
            if (s.y<=ymin) return false;
            break;
        case T:
            if (s.y>=ymax) return false;
            break;
    }
    return true;
}

point check(point s,point e,BD b)                                    //  计算直线与边界的交点
{
    point pi;
    int k;
    switch(b)
    {
        case L:
           pi.x=xmin;
           if (s.x!=e.x) pi.y=s.y+(xmin-s.x)*(e.y-s.y)/(e.x-s.x);
           else pi.y=s.y;
           break;
        case R:
            pi.x=xmax;
            if (s.x!=e.x) pi.y=s.y-(s.x-xmax)*(e.y-s.y)/(e.x-s.x);
            else pi.y=s.y;
            break;
        case B:
            pi.y=ymin;
            if (e.y!=s.y) pi.x=s.x+(e.x-s.x)*(ymin-s.y)/(e.y-s.y);
            else pi.x=s.x;
            break;
        case T:
            pi.y=ymax;
            if (e.y!=s.y) pi.x=s.x-(e.x-s.x)*(s.y-ymax)/(e.y-s.y);
            else pi.x=s.x;
            break;
    }
    return pi;
}

int EC(BD b)                                                //多边形裁剪
{
    int pl=0;
    point s=in[0];
    for (int i=1;i<=len;i++)
    {
        if (!insert(s,b)&&insert(in[i],b))
        {
             out[pl++]=check(s,in[i],b);
             out[pl++]=in[i];
        }
        if (insert(s,b)&&insert(in[i],b))
        {
            out[pl++]=in[i];
        }
        if (insert(s,b)&&!insert(in[i],b))
        {
            out[pl++]=check(in[i],s,b);
        }
        s=in[i];
    }
    return pl;
}


bool LinTai(point &s,point &e)                 //线裁剪
{

    //上裁剪
    if (s.y>=ymax&&e.y>=ymax) return false;
    if (s.y>=ymax)
    {
         s.x+=(s.y-ymax)*(e.x-s.x)/(s.y-e.y);
         s.y=ymax;
    }
    if (e.y>=ymax)
    {
        e.x-=(e.y-ymax)*(e.x-s.x)/(e.y-s.y);
        e.y=ymax;
    }

    //下裁剪
    if (s.y<=ymin&&e.y<=ymin) return false;
    if (s.y<=ymin)
    {
          s.x+=(ymin-s.y)*(e.x-s.x)/(e.y-s.y);
          s.y=ymin;
    }
    if (e.y<=ymin)
    {
          e.x-=(ymin-e.y)*(e.x-s.x)/(s.y-e.y);
          e.y=ymin;
    }

    //右裁剪
    if (s.x>=xmax&&e.x>=xmax) return  false;
    if (e.x>=xmax)
    {
         e.y-=(e.x-xmax)*(e.y-s.y)/(e.x-s.x);
         e.x=xmax;
    }

    //左裁剪
    if (s.x<=xmin&&e.x<=xmin) return false;
    if (s.x<=xmin)
    {
        s.y+=(xmin-s.x)*(e.y-s.y)/(e.x-s.x);
        s.x=xmin;
    }

    return true;
}

void myDisplay()
{
    glBegin(GL_POLYGON);
       glVertex2f(xmin,ymax);
       glVertex2f(xmax,ymax);
       glVertex2f(xmax,ymin);
       glVertex2f(xmin,ymin);
    glEnd();
    glFlush();

     point s1=s,e1=e;
    if (LinTai(s,e))
    {


        printf("%d %d %d %d
",s1.x,s1.y,s.x,s.y);

          glColor3f(0.0, 0.0, 1.0);
          setPixel(s.x,s.y,s1.x,s1.y);
          setPixel(e.x,e.y,e1.x,e1.y);

          glColor3f(0.0, 1.0, 0.0);
          setPixel(s.x,s.y,e.x,e.y);
    }
    else
    {
        glColor3f(0.0, 0.0, 1.0);
        setPixel(s1.x,s1.y,e1.x,e1.y);
    }

    glFlush();

    int i,j;
    glColor3f(1.0, 0.0, 1.0); 
    glBegin(GL_LINE_LOOP);
    for (i=0;i<len;i++)
        glVertex2f(in[i].x,in[i].y);
    glEnd();
    glFlush();
    for (i=0;i<4;i++)
    { 
    
        len=EC(BD(i));
        for(j=0;j<len;j++) in[j]=out[j];
        in[len]=out[0];

    }
    glColor3f(1.0, 1.0, 0.0);
    glBegin(GL_LINE_LOOP);
    for (i=0;i<len;i++) 
      glVertex2f(in[i].x,in[i].y);
    glEnd();

    glFlush();
}

 int main(int argc, char *argv[])
 {
     glutInit(&argc, argv);
     init();                                                     //初始化数据
     glutDisplayFunc(&myDisplay);                                //调用函数                    
     glutMainLoop();                                             //开始程序
     return 0; 
 }