Using glDrawElements does not draw my .obj file

I am trying to correctly import an .OBJ file from 3ds Max. I got this working using glBegin() & glEnd() from a previous question on here, but had really poor performance obviously, so I am trying to use glDrawElements now.

I am importing a chessboard, its game pieces, etc. The board, each game piece, and each square on the board is stored in a struct GroupObject. The way I store the data is like this:

struct Vertex
{
    float position[3];
    float texCoord[2];
    float normal[3];
    float tangent[4];
    float bitangent[3];
};

struct Material
{
    float ambient[4];
    float diffuse[4];
    float specular[4];
    float shininess;        // [0 = min shininess, 1 = max shininess]
    float alpha;            // [0 = fully transparent, 1 = fully opaque]

    std::string name;
    std::string colorMapFilename;
    std::string bumpMapFilename;

   std::vector<int> indices;
   int id;
  };

 //A chess piece or square
 struct GroupObject
 {
     std::vector<Material *> materials;
     std::string    objectName;
     std::strin开发者_StackOverflowg    groupName;
     int      index;
 };

All vertices are triangles, so there are always 3 points. When I am looping through the faces f section in the obj file, I store the v0, v1, & v2 in the Material->indices. (I am doing v[0-2] - 1 to account for obj files being 1-based and my vectors being 0-based.

So when I get to the render method, I am trying to loop through every object, which loops through every material attached to that object. I set the material information and try and use glDrawElements. However, the screen is black. I was able to draw the model just fine when I looped through each distinct material with all the indices associated with that material, and it drew the model fine. This time around, so I can use the stencil buffer for selecting GroupObjects, I changed up the loop, but the screen is black.

UPDATE Replaced original render loop with current one and screenshot of it's result Here is my render loop. The only thing I changed was the for loop(s) so they go through each object, and each material in the object in turn.

void GLEngine::drawModel()
{
ModelTextures::const_iterator iter;
GLuint texture = 0;

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

// Vertex arrays setup
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer(3, GL_FLOAT, model.getVertexSize(), model.getVertexBuffer()->position);

glEnableClientState( GL_NORMAL_ARRAY );
glNormalPointer(GL_FLOAT, model.getVertexSize(), model.getVertexBuffer()->normal);

glClientActiveTexture( GL_TEXTURE0 );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glTexCoordPointer(2, GL_FLOAT, model.getVertexSize(), model.getVertexBuffer()->texCoord);

glUseProgram(blinnPhongShader);

objects = model.getObjects();
// Loop through objects...
for( int i=0 ; i < objects.size(); ++i ) 
{
    ModelOBJ::GroupObject *object = objects[i];

    // Loop through materials used by object...
    for( int j=0 ; j<object->materials.size() ; ++j ) 
    {
        ModelOBJ::Material *pMaterial = object->materials[j];

        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pMaterial->ambient);
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pMaterial->diffuse);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pMaterial->specular);
        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, pMaterial->shininess * 128.0f);

        if (pMaterial->bumpMapFilename.empty())
        {

             //Bind the color map texture.
            texture = nullTexture;
            if (enableTextures)
            {
                iter = modelTextures.find(pMaterial->colorMapFilename);

                if (iter != modelTextures.end())
                    texture = iter->second;
            }

            glActiveTexture(GL_TEXTURE0);
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, texture);

             //Update shader parameters.
            glUniform1i(glGetUniformLocation(
                blinnPhongShader, "colorMap"), 0);
            glUniform1f(glGetUniformLocation(
                blinnPhongShader, "materialAlpha"), pMaterial->alpha);
        }
        //glDrawElements( GL_TRIANGLES, pMaterial->triangleCount * 3, GL_UNSIGNED_INT, &pMaterial->indices.front() );
        glDrawElements( GL_TRIANGLES, pMaterial->triangleCount * 3, GL_UNSIGNED_INT, model.getIndexBuffer() + pMaterial->startIndex );

    }

}
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
    glDisable(GL_BLEND);
}

Here is what the above method draws: http://img844.imageshack.us/img844/3793/chess4.png

I don't know what I am missing that's important. If it's also helpful, here is where I read a 'f' face line and store the info in the obj importer in the pMaterial->indices.

 else if (sscanf(buffer, "%d/%d/%d", &v[0], &vt[0], &vn[0]) == 3) // v/vt/vn
        {
            fscanf(pFile, "%d/%d/%d", &v[1], &vt[1], &vn[1]);
            fscanf(pFile, "%d/%d/%d", &v[2], &vt[2], &vn[2]);

            v[0] = (v[0] < 0) ? v[0] + numVertices - 1 : v[0] - 1;
            v[1] = (v[1] < 0) ? v[1] + numVertices - 1 : v[1] - 1;
            v[2] = (v[2] < 0) ? v[2] + numVertices - 1 : v[2] - 1;

currentMaterial->indices.push_back(v[0]);
currentMaterial->indices.push_back(v[1]);
currentMaterial->indices.push_back(v[2]);

UPDATE 2

Current output: http://img337.imageshack.us/img337/860/chess4s.png

I was able to fix the model with the following code

glDrawElements( GL_TRIANGLES, pMaterial->triangleCount * 3, GL_UNSIGNED_INT, model.getIndexBuffer() + pMaterial->startIndex );

When I was done importing the model, I went through running a triangleCount & set the startIndex like so. This was my solution:

for (int i = 0; i < static_cast<int>(m_attributeBuffer.size()); i++)
{
    if (m_attributeBuffer[i] != materialId)
    {
        materialId = m_attributeBuffer[i];
        ++numMaterials;
    }
}

// Allocate memory for the materials and reset counters.
m_numberOfObjectMaterials = numMaterials;
m_materials.resize(m_numberOfObjectMaterials);
numMaterials = 0;
materialId = -1;

// Build the meshes. One mesh for each unique material.
for (int i = 0; i < static_cast<int>(m_attributeBuffer.size()); i++)
{
    if (m_attributeBuffer[i] != materialId)
    {
        materialId = m_attributeBuffer[i];
        m = m_ObjectMaterials[materialId];
        m->startIndex = i * 3;
        m->triangleCount = 0;
        ++m->triangleCount;
    }
    else
    {
        ++m->triangleCount;
    }
}