如何使用opengl，c++；而不是Glut/Glu 我对OpenGL和C++的研究相对较新，并且我一直在研究一个自定义框架，在这个框架中，我被要求渲染球。我做了研究，并设法生成了一个由点构成的球体。如果可能的话，我想修改它，这样我就可以有一个实际的球体，由具有半径等属性的三角形组成。我用于生成由点生成的球体的代码如下： Mesh* Mesh::GenerateSphere() { const int Y_SEGMENT= 10; const int X_SEGMENT = 20; //const float count; Mesh*m = new Mesh(); m->numVertices = (X_SEGMENT+1)*(Y_SEGMENT+1); m->type = GL_POINTS; m->vertices = new Vector3[m->numVertices]; //s->GenerateTriangle(); for (int i = 0; i < Y_SEGMENT+1;i++) { float angleY = PI*i / Y_SEGMENT; float y = cos(angleY); float xz = sin(angleY); for (int j = 0; j < X_SEGMENT+1; j++) { float angleX = 2*PI*j / X_SEGMENT; float x = xz*cos(angleX); float z = xz*sin(angleX); Vector3 v(x,y,z); m->vertices[i * (X_SEGMENT+1)+j] = v; } } m->BufferData(); return m; } Mesh*Mesh:：GenerateSphere（） { const int Y_段=10； 常数int X_段=20； //常量浮点计数； 网格*m=新网格（）； m->数值=（X_段+1）*（Y_段+1）； m->type=GL\U点； m->顶点=新矢量3[m->numVertices]； //s->GenerateTriangle（）； 对于（int i=0；iBufferData（）； 返回m； }

这是我很久很久以前写的一些代码。我用一个三角形扇子画出了极点周围的区域，用四条带画出了球体的其余部分。当然，你可以用三角形代替四边形，但是因为三角形对仍然是平面的，所以看起来不会有什么不同，除非我弄错了——我很久没有碰过任何东西了

正如molbdnilo指出的，通过以不同的方式计算点，您将得到一个更好的球体。如果目的是对球体进行纹理贴图，那么如果细分并平滑立方体，将再次获得更好的结果，因为这样可以避免围绕极点的“挤压”。 这里有一篇很好的文章讨论了这一点：

我还应该指出，我计算法线的方法存在问题，或者在旋转时进行变换——当球体旋转时，我在观察球体时，通常会得到时髦的照明效果。（我认为这是正常的） 另外，现在看一下刚才的代码，我不确定我是否正确计算了所需的顶点数-您必须仔细检查。看起来好像我没有为阵列中的任一极点存储顶点

编辑： 以下是输出的图片：

typedef struct {
    GLfloat x, y, z;
}vec3;

void myGlutBall(float radius, int numStacks, int numSides)
{
//    vec3 points[sides * (sides-1)];
    GLfloat curRadius, curTheta, curRho, deltaTheta, deltaRho, curX,curY,curZ;
    int curStack, curSlice, numVerts = (numStacks-1)*numSides;
    vec3 points[numVerts];
    int curVert = 0;
    int t;

    deltaTheta = (2*M_PI) / numSides;
    deltaRho = M_PI / numStacks;

        for (curStack=1; curStack<numStacks; curStack++)
        {
            curRho = (3.141/2.0) - curStack*deltaRho;
            curY = sin(curRho) * radius;
            curRadius = cos(curRho) * radius;
            for (curSlice=0; curSlice<numSides; curSlice++)
            {
                curTheta = curSlice * deltaTheta;
                curX = curRadius * cos(curTheta);
                curZ = -curRadius * sin(curTheta);
                points[curVert++] = vec3{curX,curY,curZ};
            }
        }

    // option 1 - points only
    /*
    glBegin(GL_POINTS);
    glNormal3d(0,1,0);
    glVertex3d(0,radius,0);
    for (t=0; t<numVerts; t++)
    {
        curX = points[t].x;
        curY = points[t].y;
        curZ = points[t].z;
        glNormal3d(curX, curY, curZ);
        glVertex3d(curX, curY, curZ);
    }
    glNormal3d(0,-1,0);
    glVertex3d(0,-radius,0);
    glEnd();
    */

    ///////////////////////////////
    // option 2 - solid
    ///////////////////////////////
    // part A - draw the top 'lid' (tris)
    glBegin(GL_TRIANGLE_FAN);
        glNormal3d(0,1,0);
        glVertex3d(0,radius,0);
        for (t=0; t<numSides; t++)
        {
            curX = points[t].x;
            curY = points[t].y;
            curZ = points[t].z;
            glNormal3d(curX, curY, curZ);
            glVertex3d(curX, curY, curZ);
        }
            curX = points[0].x;
            curY = points[0].y;
            curZ = points[0].z;
        glNormal3d(curX, curY, curZ);
        glVertex3d(curX, curY, curZ);
    glEnd();

    // part B - draw the 'sides' (quads)
    int vertIndex;
    for (curStack=0; curStack<numStacks-2; curStack++)
    {
        vertIndex = curStack * numSides;
        glBegin(GL_QUAD_STRIP);
            for (curSlice=0; curSlice<numSides; curSlice++)
            {
                glNormal3d(points[vertIndex+curSlice].x, points[vertIndex+curSlice].y, points[vertIndex+curSlice].z);
                glVertex3d(points[vertIndex+curSlice].x, points[vertIndex+curSlice].y, points[vertIndex+curSlice].z);

                glNormal3d(points[vertIndex+numSides+curSlice].x, points[vertIndex+numSides+curSlice].y, points[vertIndex+numSides+curSlice].z);
                glVertex3d(points[vertIndex+numSides+curSlice].x, points[vertIndex+numSides+curSlice].y, points[vertIndex+numSides+curSlice].z);
            }
            glNormal3d(points[vertIndex].x, points[vertIndex].y, points[vertIndex].z);
            glVertex3d(points[vertIndex].x, points[vertIndex].y, points[vertIndex].z);
            glNormal3d(points[vertIndex+numSides].x, points[vertIndex+numSides].y, points[vertIndex+numSides].z);
            glVertex3d(points[vertIndex+numSides].x, points[vertIndex+numSides].y, points[vertIndex+numSides].z);
        glEnd();
    }

    // part C - draw the bottom 'lid' (tris)
    glBegin(GL_TRIANGLE_FAN);
        glNormal3d(0,-1,0);
        glVertex3d(0,-radius,0);
        for (t=0; t<numSides-1; t++)
        {
            curX = points[numVerts-1-t].x;
            curY = points[numVerts-1-t].y;
            curZ = points[numVerts-1-t].z;
            glNormal3d(curX, curY, curZ);
            glVertex3d(curX, curY, curZ);
        }
            curX = points[numVerts-1].x;
            curY = points[numVerts-1].y;
            curZ = points[numVerts-1].z;
        glNormal3d(curX, curY, curZ);
        glVertex3d(curX, curY, curZ);
    glEnd();

}

typedef结构{
glx，y，z；
}vec3；
void myGlutBall（浮动半径、int numStacks、int numSides）
{
//vec3点[侧面*（侧面-1）]；
GLfloat curRadius，curTheta，curRho，deltaTheta，deltaRho，curX，curY，curZ；
int curStack，curSlice，numVerts=（numStacks-1）*numSides；
向量3点[numVerts]；
int-curVert=0；
int t；
德尔塔塔=（2*M_PI）/numSides；
deltaRho=M_PI/numStacks；
对于（curStack=1；curStack在我的渲染课上，我被教导将一个球体想象成一个圆形网格。因此，首先，你需要在x和y中实现一个尺寸为1的网格，以位置（0,0,0）为中心，该位置将被n行（rowMax）和m列（colMax）细分：

//辅助函数
内联整数索引（整数i，整数j）
{
返回i+j*（m_colMax+1）；
}
float numCoords=3*rowMax*colMax；//数组大小
float*coordData=newfloat[numCoords]；//带坐标位置的数组
//填充坐标位置[更改]
对于（int j=0；j）你看过了吗？你可以通过细分一个二十面体得到一个“更平滑”的球体下面是免费glut项目中sphere的一个实现：由于框架的布局，我不能使用glut，我不认为它是重复的，因为帖子上的答案依赖于glu/glut的使用，而我不能使用。
// Aux function
inline int index (int i, int j)
{
    return i + j*(m_colMax + 1);
}

float numCoords = 3*rowMax*colMax; // Array size

float *coordData = new float[numCoords]; // Array with coordinate positions

// Fill coordinate positions [to change]
for (int j = 0; j <= rowMax; j++) {
    for (int i = 0; i <= colMax; i++) {
        int k = index(i, j);
        coordData[k] = (float)i / m_colMax - (0.5f);
        coordData[k + 1] = (float)j / m_rowMax - (0.5f);
        coordData[k + 2] = 0;
    }
}

// Fill index
int k = 0;
GLuint *indexData = new GLuint[numCoords]; // Array with indexing data 
for (int j = 0; j < rowMax; j++) {
    for (int i = 0; i < colMax; i++) {
        indexData[k++] = index (i, j);
        indexData[k++] = index (i + 1, j + 1);
        indexData[k++] = index (i, j + 1);
        indexData[k++] = index (i, j);
        indexData[k++] = index (i + 1, j);
        indexData[k++] = index (i + 1, j + 1);          
    }
}

// Fill coordinate positions 
// Pi variable can be a define or declared somewhere in your code
float radius = 1.0f;
for (int j = 0; j <= rowMax; j++) {
    for (int i = 0; i <= colMax; i++) {
        int k = index(i, j);
        float teta = ((float)i / m_colMax) * 2 * (float)Pi;
        float fi = ((float)j / m_rowMax)*(float)Pi;
        coordData[k] = radius*(cos (teta))*(sin (fi));
        coordData[k + 1] = radius*(cos (fi));
        coordData[k + 2] = 1.0f*(sin (teta))*(sin (fi));
    }
}