vc实现bezier曲面,要求用不同颜色显 示曲面和曲面的控制网格,并且可以取消曲面控制网格的显示,允 许交互式地改变控制网格的定点位置,以观看曲面形状的改变;能 够通过对话框、菜单等方式设置曲面的配置参数（书写代码）

以下是一个简单的实现 Bezier 曲面的示例代码，包括控制网格的交互式修改和显示开关：

#include <vector>
#include <iostream>
#include <GL/glut.h>

// 控制点列表
std::vector<std::vector<GLfloat>> controlPoints = {
    {-1.5, -1.5, 4.0},
    {-0.5, -1.5, 2.0},
    {0.5, -1.5, -1.0},
    {1.5, -1.5, 2.0},
    {-1.5, -0.5, 1.0},
    {-0.5, -0.5, 3.0},
    {0.5, -0.5, 0.0},
    {1.5, -0.5, -1.0},
    {-1.5, 0.5, 4.0},
    {-0.5, 0.5, 0.0},
    {0.5, 0.5, 3.0},
    {1.5, 0.5, 4.0},
    {-1.5, 1.5, -2.0},
    {-0.5, 1.5, -2.0},
    {0.5, 1.5, 0.0},
    {1.5, 1.5, -1.0}
};

// 曲面分辨率
const int resolution = 20;

// 控制网格显示开关
bool showControlGrid = true;

// 当前选中的控制点
int selectedPoint = -1;

// 曲面配置参数
float uMin = 0.0f, uMax = 1.0f, vMin = 0.0f, vMax = 1.0f;

// 绘制单个 Bezier 曲线
void drawBezierCurve(std::vector<GLfloat> points)
{
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);
    for (int i = 0; i <= resolution; ++i) {
        float t = i / (float)resolution;
        GLfloat x = 0, y = 0, z = 0;
        for (int j = 0; j < points.size(); ++j) {
            x += points[j] * pow(1 - t, points.size() - j - 1) * pow(t, j);
            y += points[j + 1] * pow(1 - t, points.size() - j - 1) * pow(t, j);
            z += points[j + 2] * pow(1 - t, points.size() - j - 1) * pow(t, j);
            j += 2;
        }
        glVertex3f(x, y, z);
    }
    glEnd();
}

// 绘制 Bezier 曲面
void drawBezierSurface()
{
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_TRIANGLES);
    for (int i = 0; i < resolution; ++i) {
        for (int j = 0; j < resolution; ++j) {
            float u1 = i / (float)resolution, u2 = (i + 1) / (float)resolution;
            float v1 = j / (float)resolution, v2 = (j + 1) / (float)resolution;
            std::vector<GLfloat> points = {
                controlPoints[0][0], controlPoints[0][1], controlPoints[0][2],
                controlPoints[4][0], controlPoints[4][1], controlPoints[4][2],
                controlPoints[12][0], controlPoints[12][1], controlPoints[12][2],
                controlPoints[3][0], controlPoints[3][1], controlPoints[3][2],
                controlPoints[7][0], controlPoints[7][1], controlPoints[7][2],
                controlPoints[15][0], controlPoints[15][1], controlPoints[15][2]
            };
            points.insert(points.end(), {
                controlPoints[1][0], controlPoints[1][1], controlPoints[1][2],
                controlPoints[5][0], controlPoints[5][1], controlPoints[5][2],
                controlPoints[13][0], controlPoints[13][1], controlPoints[13][2],
                controlPoints[2][0], controlPoints[2][1], controlPoints[2][2],
                controlPoints[6][0], controlPoints[6][1], controlPoints[6][2],
                controlPoints[14][0], controlPoints[14][1], controlPoints[14][2]
            });
            for (int k = 0; k < points.size(); k += 3) {
                float u = u1 + (u2 - u1) * (points[k + 1] - v1) / (v2 - v1);
                float x = 0, y = 0, z = 0;
                for (int l = 0; l < points.size(); l += 3) {
                    x += points[l] * pow(1 - u, 2) * pow(u, l / 3);
                    y += points[l + 1] * pow(1 - u, 2) * pow(u, l / 3);
                    z += points[l + 2] * pow(1 - u, 2) * pow(u, l / 3);
                }
                glVertex3f(x, y, z);
            }
            points = {
                controlPoints[4][0], controlPoints[4][1], controlPoints[4][2],
                controlPoints[5][0], controlPoints[5][1], controlPoints[5][2],
                controlPoints[6][0], controlPoints[6][1], controlPoints[6][2],
                controlPoints[12][0], controlPoints[12][1], controlPoints[12][2],
                controlPoints[13][0], controlPoints[13][1], controlPoints[13][2],
                controlPoints[14][0], controlPoints[14][1], controlPoints[14][2]
            };
            for (int k = 0; k < points.size(); k += 3) {
                float u = u1 + (u2 - u1) * (points[k + 1] - v1) / (v2 - v1);
                float x = 0, y = 0, z = 0;
                for (int l = 0; l < points.size(); l += 3) {
                    x += points[l] * pow(1 - u, 2) * pow(u, l / 3);
                    y += points[l + 1] * pow(1 - u, 2) * pow(u, l / 3);
                    z += points[l + 2] * pow(1 - u, 2) * pow(u, l / 3);
                }
                glVertex3f(x, y, z);
            }
        }
    }
    glEnd();
}

// 绘制控制点网格
void drawControlGrid()
{
    glColor3f(0.5f, 0.5f, 0.5f);
    glBegin(GL_LINES);
    for (int i = 0; i < controlPoints.size(); ++i) {
        for (int j = i + 1; j < controlPoints.size(); ++j) {
            glVertex3fv(&controlPoints[i][0]);
            glVertex3fv(&controlPoints[j][0]);
        }
    }
    glEnd();
    for (int i = 0; i < controlPoints.size(); ++i) {
        if (i == selectedPoint)
            glColor3f(1.0f, 0.0f, 1.0f);
        else
            glColor3f(1.0f, 1.0f, 1.0f);
        glPushMatrix();
        glTranslatef(controlPoints[i][0], controlPoints[i][1], controlPoints[i][2]);
        glutSolidSphere(0.05, 10, 10);
        glPopMatrix();
    }
}

// 鼠标点击事件处理
void onMouse(int button, int state, int x, int y)
{
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
        selectedPoint = -1;
        float minDist = 0.05;
        for (int i = 0; i < controlPoints.size(); ++i) {
            float dist = sqrt(pow(controlPoints[i][0] - (2 * x / (float)glutGet(GLUT_WINDOW_WIDTH) - 1), 2) +
                              pow(controlPoints[i][1] - (2 * (glutGet(GLUT_WINDOW_HEIGHT) - y) / (float)glutGet(GLUT_WINDOW_HEIGHT) - 1), 2));
            if (dist < minDist) {
                selectedPoint = i;
                break;
            }
        }
    }
}

// 鼠标移动事件处理
void onMotion(int x, int y)
{
    if (selectedPoint >= 0) {
        controlPoints[selectedPoint][0] = 2 * x / (float)glutGet(GLUT_WINDOW_WIDTH) - 1;
        controlPoints[selectedPoint][1] = 2 * (glutGet(GLUT_WINDOW_HEIGHT) - y) / (float)glutGet(GLUT_WINDOW_HEIGHT) - 1;
    }
}

// 菜单事件处理
void onMenu(int value)
{
    switch (value) {
    case 1:
        showControlGrid = !showControlGrid;
        break;
    case 2:
        std::cout << "Enter uMin uMax vMin vMax: ";
        std::cin >> uMin >> uMax >> vMin >> vMax;
        break;
    }
    glutPostRedisplay();
}

// 主函数
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(600, 600);
    glutCreateWindow("Bezier Surface");
    glutDisplayFunc([]() {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glEnable(GL_DEPTH_TEST);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(60.0, 1.0, 0.1, 20.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(3.0, 3.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
        // 绘制曲面
        drawBezierSurface();
        // 绘制控制网格
        if (showControlGrid) {
            drawControlGrid();
        }
        glutSwapBuffers();
    });
    glutMouseFunc(onMouse);
    glutMotionFunc(onMotion);
    glutCreateMenu(onMenu);
    glutAddMenuEntry("Toggle Control Grid", 1);
    glutAddMenuEntry("Set Parameter Range", 2);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    glutMainLoop();
    return 0;
}

该示例代码使用 OpenGL 库实现了一个简单的 Bezier 曲面，包括控制网格的交互式修改和显示开关，以及通过菜单设置曲面的配置参数。其中，`controlPoints` 列表表示曲面控制点的坐标，`resolution` 表示曲面分辨率，`showControlGrid` 表示控制网格的显示开关，`selectedPoint` 表示当前选中的控制点，`uMin`、`uMax`、`vMin` 和 `vMax` 表示曲面的参数范围。在 `drawBezierCurve()` 函数中实现了单个 Bezier 曲线的绘制，而在 `drawBezierSurface()` 函数中则使用了嵌套循环计算并绘制整个 Bezier 曲面。在 `drawControlGrid()` 函数中绘制了控制点网格和控制点的球形表示。`onMouse()` 和 `onMotion()` 函数分别处理鼠标点击和移动事件，用于交互式修改控制点坐标。在 `onMenu()` 函数中实现了菜单事件的处理，用于切换控制网格显示和设置曲面的参数范围。最后，在 `main()` 函数中创建 OpenGL 窗口和菜单，并进入主循环等待事件。