Du mal à comprendre les indices avec glDrawElements

Je suis en train de dessiner un terrain avec GL_TRIANGLE_STRIP et glDrawElements mais je vais avoir bien du mal à comprendre les indices chose derrière glDrawElements...

Voici ce que j'ai à ce jour:

void Terrain::GenerateVertexBufferObjects(float ox, float oy, float oz) {
    float startWidth, startLength, *vArray;
    int vCount, vIndex = -1;

    //width = length = 256

    startWidth = (width /2.0f) - width;
    startLength = (length /2.0f) - length;

    vCount = 3 * width * length;
    vArray = new float[vCount];

    for(int z = 0; z < length; z++) {
        //vIndex == vIndex + width * 3  ||  width * 3 = 256 * 3 = 768
        for(int x = 0; x < width; x++) {
            vArray[++vIndex] = ox + startWidth + (x * stepWidth);
            vArray[++vIndex] = oy + heights[z][x];
            vArray[++vIndex] = oz + startLength + (z * stepLength);
        }
    }

    glGenBuffers(1, &vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vCount, vArray, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void Terrain::DrawVBO(unsigned int texID, float ox, float oy, float oz) {
    float terrainLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };

    if(!generatedVBOs) {
        GenerateVertexBufferObjects(ox, oy, oz);
        generatedVBOs = true;
    }

    unsigned int indices[] = { 0, 768, 3, 771 };

    glGenBuffers(1, &indexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * 4, indices, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glEnableClientState(GL_VERTEX_ARRAY);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glVertexPointer(3, GL_FLOAT, 0, 0);

    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, terrainLight);
    glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_INT, 0);

    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    glDisableClientState(GL_VERTEX_ARRAY);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

Je crois que mon vArray est correct, j'utilise les mêmes valeurs lors de l'élaboration de glBegin(GL_TRIANGLE_STRIP)/glEnd qui fonctionne très bien.

Ma conjecture était d'utiliser juste l'indice de la x coordonnées de chaque sommet. Mais je n'ai aucune idée si c'est la bonne façon d'utiliser les indices avec glDrawElements.

• 0: Indice de la coordonnée x du premier sommet du triangle. Emplacement: (-128, -128).
• 768: l'Indice de la coordonnée x du deuxième sommet du triangle. Emplacement: (-128, -127)
• 3: Indice de la coordonnée x du troisième sommet du triangle. Emplacement: (-127, -128)
• 771: l'Indice de la coordonnée x de la quatrième sommet, qui fera appel à un deuxième triangle. Emplacement: (-127, -127).

Je pense que tout est de donner un sens à ce jour?

Ce qui ne marche pas, c'est que les valeurs de l'emplacement ci-dessus (que j'ai doublé vérifié sur vArray et qu'ils sont corrects) ne sont pas les mêmes qui glDrawElements est à l'aide. Deux triangles sont dessinés, mais ils sont beaucoup plus gros que ce qu'ils devraient être. Il démarre correctement à (-128, -128) mais il va quelque chose comme (-125, -125) au lieu de (-127, -127).

Je ne peux pas comprendre ce que je fais mal ici...