Texture multiple triangles of a circle in OpenGL - c++

Question

I'm trying to center a square texture on a circle using openGL, I have created a loop that fills an array with my circle coordinates, followed by my +/-normals for lighting, finally followed by my (x,y) for the texture coordinates.
For some reason the image ends up kind of smooshed instead of evenly spreading out around the circle. I'm ot sure if my calculations for the polar to cartesian coordinates are a little off or what.
Below is a section of the code as well as an image of the output.
{
/*FIX STILL NEEDED TO DYNAMICALLY UPDATE THESE VALUES*/
//When changing numberOfSides need to also update indices[] to numberOfSides*3 and allCircleVertices[] to numberOfVertices*numberOfSides
GLfloat x = 0;
GLfloat y = 0;
GLfloat z = 0;
GLfloat radius = 4;
GLuint numberOfSides = 20;
GLuint numberOfVertices = numberOfSides + 1;
GLuint k = 22;
GLuint angle = 360 / numberOfSides;
GLushort indices[60];
GLfloat doublePi = 2.0f * M_PI;
GLfloat* circleVerticesX = new GLfloat[numberOfVertices];
GLfloat* circleVerticesY = new GLfloat[numberOfVertices];
GLfloat* circleVerticesZ = new GLfloat[numberOfVertices];
GLfloat allCircleVertices[420]; /*= new GLfloat[numberOfVertices * numberOfSides];*/
circleVerticesX[0] = x;
circleVerticesY[0] = y;
circleVerticesZ[0] = z;
//Loop to determine angles between vertices
for (int i = 1; i < numberOfVertices; i++)
{
circleVerticesX[i] = x + (radius * cos(i * doublePi / numberOfSides));
circleVerticesY[i] = y;
circleVerticesZ[i] = z + (radius * sin(i * doublePi / numberOfSides));
}
//Loop to fill array with vertices
for (int i = 0; i < numberOfVertices; i++)
{
allCircleVertices[i * 8] = circleVerticesX[i];
allCircleVertices[(i * 8) + 1] = circleVerticesY[i];
allCircleVertices[(i * 8) + 2] = circleVerticesZ[i];
allCircleVertices[(i * 8) + 3] = 0.0f;
allCircleVertices[(i * 8) + 4] = 1.0f;
allCircleVertices[(i * 8) + 5] = 0.0f;
if ((i * 8) + 6 == 6)
{
allCircleVertices[6] = 0.5f;
}
else
{
allCircleVertices[(i * 8 + 6)] = 0.5 * (sin(angle * i));
}
if ((i * 8 + 7) == 7)
{
allCircleVertices[7] = 0.5f;
}
else
{
allCircleVertices[(i * 8 + 7)] = 0.5 * (cos(angle * i));
}
}
//For loop to fill Indices array with correct indices based on number of sides
for (int i = 0; i < numberOfSides; i++)
{
if (i == (numberOfSides - 1))
{
indices[i * 3] = 0;
indices[(i * 3) + 1] = indices[2];
indices[(i * 3) + 2] = numberOfSides;
//cout << indices[i * 3] << ", " << indices[(i * 3) + 1] << ", " << indices[(i * 3) + 2] << endl;
}
else
{
indices[i * 3] = 0;
indices[(i * 3) + 1] = i + 2;
indices[(i * 3) + 2] = i + 1;
//cout << indices[i * 3] << ", " << indices[(i * 3) + 1] << ", " << indices[(i * 3) + 2] << endl;
}
}
const GLuint floatsPerVertex = 3;
const GLuint floatsPerNormal = 3;
const GLuint floatsPerUV = 2;
glGenVertexArrays(1, &mesh.vao); // we can also generate multiple VAOs or buffers at the same time
glBindVertexArray(mesh.vao);
// Create 2 buffers: first one for the vertex data; second one for the indices
glGenBuffers(2, mesh.vbos);
glBindBuffer(GL_ARRAY_BUFFER, mesh.vbos[0]); // Activates the buffer
glBufferData(GL_ARRAY_BUFFER, sizeof(allCircleVertices), allCircleVertices, GL_STATIC_DRAW); // Sends vertex or coordinate data to the GPU
mesh.nIndices = sizeof(indices) / sizeof(indices[0]) * (floatsPerVertex + floatsPerNormal + floatsPerUV);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.vbos[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// Strides between vertex coordinates is 6 (x, y, z, r, g, b, a). A tightly packed stride is 0.
GLint stride = sizeof(float) * (floatsPerVertex + floatsPerNormal + floatsPerUV);// The number of floats before each
// Create Vertex Attribute Pointers
glVertexAttribPointer(0, floatsPerVertex, GL_FLOAT, GL_FALSE, stride, 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, floatsPerNormal, GL_FLOAT, GL_FALSE, stride, (char*)(sizeof(float)* floatsPerVertex));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, floatsPerUV, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float)* (floatsPerVertex + floatsPerNormal)));
glEnableVertexAttribArray(2);
}