Hello,

So I have been looking around for a good function that generates a sphere for OpenGL and I found the function below.

I am not trying to simply cut and paste code in my project so I and trying to understand how it works.

It seems to me that the first three arguments are the x, y, and z coordinates of the center of the sphere and the fourth is the radius.

What I don't understand is the fifth argument; is that the number of sections or "poles" for the sphere being generated?

Thank you for your time:

Source: https://gist.github.com/stuartjmoore/1076642

Code :
void renderSphere(float cx, float cy, float cz, float r, int p)
 
{
 
    float theta1 = 0.0, theta2 = 0.0, theta3 = 0.0;
 
    float ex = 0.0f, ey = 0.0f, ez = 0.0f;
 
    float px = 0.0f, py = 0.0f, pz = 0.0f;
 
    GLfloat vertices[p*6+6], normals[p*6+6], texCoords[p*4+4];
 
 
 
    if( r < 0 )
 
        r = -r;
 
 
 
    if( p < 0 )
 
        p = -p;
 
 
 
    for(int i = 0; i < p/2; ++i)
 
    {
 
        theta1 = i * (M_PI*2) / p - M_PI_2;
 
        theta2 = (i + 1) * (M_PI*2) / p - M_PI_2;
 
 
 
        for(int j = 0; j <= p; ++j)
 
        {
 
            theta3 = j * (M_PI*2) / p;
 
 
 
            ex = cosf(theta2) * cosf(theta3);
 
            ey = sinf(theta2);
 
            ez = cosf(theta2) * sinf(theta3);
 
            px = cx + r * ex;
 
            py = cy + r * ey;
 
            pz = cz + r * ez;
 
 
 
            vertices[(6*j)+(0%6)] = px;
 
            vertices[(6*j)+(1%6)] = py;
 
            vertices[(6*j)+(2%6)] = pz;
 
 
 
            normals[(6*j)+(0%6)] = ex;
 
            normals[(6*j)+(1%6)] = ey;
 
            normals[(6*j)+(2%6)] = ez;
 
 
 
            texCoords[(4*j)+(0%4)] = -(j/(float)p);
 
            texCoords[(4*j)+(1%4)] = 2*(i+1)/(float)p;
 
 
 
 
 
            ex = cosf(theta1) * cosf(theta3);
 
            ey = sinf(theta1);
 
            ez = cosf(theta1) * sinf(theta3);
 
            px = cx + r * ex;
 
            py = cy + r * ey;
 
            pz = cz + r * ez;
 
 
 
            vertices[(6*j)+(3%6)] = px;
 
            vertices[(6*j)+(4%6)] = py;
 
            vertices[(6*j)+(5%6)] = pz;
 
 
 
            normals[(6*j)+(3%6)] = ex;
 
            normals[(6*j)+(4%6)] = ey;
 
            normals[(6*j)+(5%6)] = ez;
 
 
 
            texCoords[(4*j)+(2%4)] = -(j/(float)p);
 
            texCoords[(4*j)+(3%4)] = 2*i/(float)p;
 
        }
 
        glVertexPointer(3, GL_FLOAT, 0, vertices);
 
        glNormalPointer(GL_FLOAT, 0, normals);
 
        glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
 
        glDrawArrays(GL_TRIANGLE_STRIP, 0, (p+1)*2);
 
    }
 
}