多边形的Sutherland-Hodgman裁减算法用c++和opengl实现代码，可以用鼠标交互

以下是使用C++和OpenGL实现Sutherland-Hodgman算法的多边形裁剪的代码。这个代码还实现了鼠标交互，可以通过鼠标绘制裁剪窗口。

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

// 窗口大小
const int WIDTH = 800;
const int HEIGHT = 600;

// 多边形点数
const int N = 6;

// 多边形顶点坐标
GLfloat polygon[N][2] = {
    {-0.8f, 0.5f},
    {-0.3f, 0.8f},
    {0.2f, 0.5f},
    {0.4f, -0.3f},
    {0.1f, -0.7f},
    {-0.5f, -0.5f}
};

// 裁剪窗口顶点坐标
GLfloat clipWindow[4][2] = {
    {-0.5f, 0.4f},
    {0.5f, 0.4f},
    {0.5f, -0.4f},
    {-0.5f, -0.4f}
};

// 判断点是否在裁剪窗口内
bool inside(GLfloat p[2]) {
    return p[0] >= clipWindow[0][0] && p[0] <= clipWindow[1][0]
        && p[1] >= clipWindow[3][1] && p[1] <= clipWindow[0][1];
}

// 计算交点
GLfloat* intersection(GLfloat p1[2], GLfloat p2[2], int edge) {
    static GLfloat i[2];
    GLfloat edgeX1 = clipWindow[edge][0];
    GLfloat edgeY1 = clipWindow[edge][1];
    GLfloat edgeX2 = clipWindow[(edge + 1) % 4][0];
    GLfloat edgeY2 = clipWindow[(edge + 1) % 4][1];

    if (edge == 0) {
        i[0] = p1[0] + (p2[0] - p1[0]) * (edgeY1 - p1[1]) / (p2[1] - p1[1]);
        i[1] = edgeY1;
    } else if (edge == 1) {
        i[0] = p1[0] + (p2[0] - p1[0]) * (edgeY1 - p1[1]) / (p2[1] - p1[1]);
        i[1] = edgeY1;
    } else if (edge == 2) {
        i[0] = edgeX1;
        i[1] = p1[1] + (p2[1] - p1[1]) * (edgeX1 - p1[0]) / (p2[0] - p1[0]);
    } else if (edge == 3) {
        i[0] = edgeX1;
        i[1] = p1[1] + (p2[1] - p1[1]) * (edgeX1 - p1[0]) / (p2[0] - p1[0]);
    }

    return i;
}

// Sutherland-Hodgman算法裁剪
void sutherlandHodgman() {
    int k = 0;
    GLfloat newPolygon[N][2];

    for (int i = 0; i < N; i++) {
        GLfloat* p1 = polygon[i];
        GLfloat* p2 = polygon[(i + 1) % N];

        // 如果第一个点在裁剪窗口内
        if (inside(p1)) {
            // 如果第二个点也在裁剪窗口内
            if (inside(p2)) {
                newPolygon[k][0] = p2[0];
                newPolygon[k][1] = p2[1];
                k++;
            } else {
                // 如果第二个点在裁剪窗口外，计算交点
                GLfloat* i = intersection(p1, p2, 0);
                if (inside(i)) {
                    newPolygon[k][0] = i[0];
                    newPolygon[k][1] = i[1];
                    k++;
                }
            }
        } else {
            // 如果第一个点在裁剪窗口外，计算交点
            if (inside(p2)) {
                GLfloat* i = intersection(p1, p2, 0);
                if (inside(i)) {
                    newPolygon[k][0] = i[0];
                    newPolygon[k][1] = i[1];
                    k++;
                }
                newPolygon[k][0] = p2[0];
                newPolygon[k][1] = p2[1];
                k++;
            } else {
                // 如果第二个点也在裁剪窗口外，不处理
            }
        }
    }

    // 更新多边形顶点
    N = k;
    for (int i = 0; i < N; i++) {
        polygon[i][0] = newPolygon[i][0];
        polygon[i][1] = newPolygon[i][1];
    }
}

// 绘制多边形
void drawPolygon() {
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_POLYGON);
    for (int i = 0; i < N; i++) {
        glVertex2f(polygon[i][0], polygon[i][1]);
    }
    glEnd();
}

// 绘制裁剪窗口
void drawClipWindow() {
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_LINE_LOOP);
    for (int i = 0; i < 4; i++) {
        glVertex2f(clipWindow[i][0], clipWindow[i][1]);
    }
    glEnd();
}

// 绘制函数
void display() {
    glClear(GL_COLOR_BUFFER_BIT);

    drawPolygon();
    drawClipWindow();

    glFlush();
}

// 鼠标绘制裁剪窗口
void mouse(int button, int state, int x, int y) {
    static int k = 0;
    static bool started = false;

    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        float mx = (float)x / WIDTH;
        float my = (float)(HEIGHT - y) / HEIGHT;

        if (!started) {
            clipWindow[k][0] = mx;
            clipWindow[k][1] = my;
            k++;
            started = true;
        } else {
            clipWindow[k][0] = mx;
            clipWindow[k][1] = my;
            k++;

            if (k == 4) {
                k = 0;
                started = false;
                sutherlandHodgman();
            }
        }
    }

    glutPostRedisplay();
}

// 初始化
void init() {
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-1.0f, 1.0f, -1.0f, 1.0f);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char* argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow("Sutherland-Hodgman Algorithm");

    init();

    glutDisplayFunc(display);
    glutMouseFunc(mouse);

    glutMainLoop();

    return 0;
}

在这个代码中，我们使用了OpenGL库来进行绘制。我们定义了一个`polygon`数组来存储多边形顶点坐标，以及一个`clipWindow`数组来存储裁剪窗口的顶点坐标。在`display`函数中，我们绘制多边形和裁剪窗口。在`mouse`函数中，我们通过鼠标交互来绘制裁剪窗口，并调用`Sutherland-Hodgman`算法进行裁剪。最后，我们使用`glutMainLoop`函数来进入主循环，等待用户操作。

使用这个代码，您可以通过鼠标绘制裁剪窗口，并看到裁剪后的多边形。