title: Using glColorPointer with glDrawElements results in nothing being drawn
body: <p>I'm working on just making uniformly colors spheres for a project and I'm running into an issue. The spheres run fine but when I try to color them with glColorPointer they stop appearing. OpenGL isn't showing any errors when I call glGetError so I'm at a loss for why this would happen.</p>
  
  <p>The code to generate the vertices, colors etc:</p>
  
  <pre><code>void SphereObject::setupVertices()
  {
      //determine the array sizes
      //vertices per row (+1 for the repeated one at the end) * three for each coordinate
      //times the number of rows
      int arraySize = myNumVertices * 3;
      myNumIndices = (myVerticesPerRow + 1) * myRows * 2;
      myVertices = new GLdouble[arraySize];
      myIndices = new GLuint[myNumIndices];
      myNormals = new GLdouble[arraySize];
      myColors = new GLint[myNumVertices * 4];
  
      //use spherical coordinates to calculate the vertices
      double phiIncrement = 360 / myVerticesPerRow;
      double thetaIncrement = 180 / (double)myRows;
      int arrayIndex = 0;
      int colorArrayIndex = 0;
      int indicesIndex = 0;
      double x, y, z = 0;
  
      for(double theta = 0; theta &lt;= 180; theta += thetaIncrement)
      {
          //loop including the repeat for the last vertex
          for(double phi = 0; phi &lt;= 360; phi += phiIncrement)
          {
              //make sure that the last vertex is repeated
              if(360 - phi &lt; phiIncrement)
              {
                  x = myRadius * sin(radians(theta)) * cos(radians(0));
                  y = myRadius * sin(radians(theta)) * sin(radians(0));
                  z = myRadius * cos(radians(theta));
              }
              else
              {
                  x = myRadius * sin(radians(theta)) * cos(radians(phi));
                  y = myRadius * sin(radians(theta)) * sin(radians(phi));
                  z = myRadius * cos(radians(theta));
              }
  
              myColors[colorArrayIndex] = myColor.getX();
              myColors[colorArrayIndex + 1] = myColor.getY();
              myColors[colorArrayIndex + 2] = myColor.getZ();
              myColors[colorArrayIndex + 3] = 1;
  
              myVertices[arrayIndex] = x;
              myVertices[arrayIndex + 1] = y;
              myVertices[arrayIndex + 2] = z;
  
              if(theta &lt;= 180 - thetaIncrement)
              {
                  myIndices[indicesIndex] = arrayIndex / 3; 
  
                  myIndices[indicesIndex + 1] = (arrayIndex / 3) + myVerticesPerRow + 1;
  
                  indicesIndex += 2;
              }
  
              arrayIndex += 3;
              colorArrayIndex += 4;
          }
      }
  }
  </code></pre>
  
  <p>And the code to actually render the thing</p>
  
  <pre><code>void SphereObject::render()
  {
      glPushMatrix();
      glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
      glEnableClientState(GL_COLOR_ARRAY);
      glColorPointer(4, GL_INT, 0, myColors);
      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3, GL_DOUBLE, 0, myVertices);
      glDrawElements(GL_QUAD_STRIP, myNumIndices, GL_UNSIGNED_INT, myIndices);
      glDisableClientState(GL_VERTEX_ARRAY);
      glDisableClientState(GL_COLOR_ARRAY);
      glPopClientAttrib();
      glPopMatrix();
  }
  </code></pre>
  
  <p>Any and all help would be appreciated. I'm really having a hard time for some reason.</p>