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

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);

    }

}