Problemi nell'utilizzo dei VBO per il rendering dei vertici - OpenGL

Question

Sto trasferendo le funzioni dei miei array di vertici in VBO per aumentare la velocità della mia applicazione.

qui era il mio originale di lavoro del vertice di matrice funzione di rendering:

void BSP::render() 
{ 
    glFrontFace(GL_CCW); 

    // Set up rendering states 
    glEnableClientState(GL_VERTEX_ARRAY); 
    glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

    glVertexPointer(3, GL_FLOAT, sizeof(Vertex), &vertices[0].x); 

    glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), &vertices[0].u); 

    // Draw 
    glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, indices); 

    // End of rendering - disable states 
    glDisableClientState(GL_VERTEX_ARRAY); 
    glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
} 

funzionava alla grande!

Ora li sto spostando in VBO e il mio programma ha effettivamente causato il blocco della mia scheda grafica. L'installazione sui miei vertici e indici è esattamente la stessa.

Nuova configurazione:

vboId è configurato nel bsp.h in questo modo: GLuint vboId [2];

Non ottengo alcun errore quando eseguo semplicemente la funzione createVBO()!

void BSP::createVBO() 
{ 

    // Generate buffers 
    glGenBuffers(2, vboId); 

    // Bind the first buffer (vertices) 
    glBindBuffer(GL_ARRAY_BUFFER, vboId[0]); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 

    // Now save indices data in buffer 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId[1]); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 

} 

E il codice di rendering per VBOS. Sono abbastanza sicuro che sia qui. Voglio solo rendere ciò che è nel VBO come ho fatto nell'array dei vertici.

Render:

void BSP::renderVBO() 
{ 
    glBindBuffer(GL_ARRAY_BUFFER, vboId[0]);   // for vertex coordinates 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId[1]); // for indices 

    // do same as vertex array except pointer 
    glEnableClientState(GL_VERTEX_ARRAY);    // activate vertex coords array 
    glVertexPointer(3, GL_FLOAT, 0, 0);    // last param is offset, not ptr 

    // draw the bsp area 
    glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0)); 

    glDisableClientState(GL_VERTEX_ARRAY);   // deactivate vertex array 

    // bind with 0, so, switch back to normal pointer operation 
    glBindBuffer(GL_ARRAY_BUFFER, 0); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 
} 

Non sono sicuro che l'errore è, ma sono abbastanza sicuro che la mia funzione di rendering sbagliato. Vorrei che ci fosse un tutorial più unificato su questo perché ci sono un sacco online ma spesso si contraddicono a vicenda.

Answer 1

Se si passano gli stessi dati a glDrawElements quando non si utilizza VBO e gli stessi dati nel buffer VBO. Quindi i parametri sono leggermente diversi, senza FBO hai usato GL_UNSIGNED_SHORT e con FBO hai usato GL_UNSIGNED_BYTE. Quindi penso che VBO chiamata dovrebbe essere simile che:

glDrawElements(GL_TRIANGLES, numVertices, GL_UNSIGNED_SHORT, 0); 

Anche guardare this tutorial, ci sono i buffer VBO ha spiegato molto bene.

Answer 2

Inoltre ciò che ha detto Miro (la GL_UNSIGNED_BYTE dovrebbe essere GL_UNSIGNED_SHORT), non credo che si desidera utilizzare numVertices ma numIndices, come nella vostra chiamata non-VBO.

glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, 0); 

In caso contrario il codice sia molto valida e se questo non risolve il problema, forse l'errore è da qualche altra parte.

E dal modo in cui la cosa BUFFER_OFFSET(i) usuaully è solo una definizione per ((char*)0+(i)), quindi si può solo passare anche nella traslazione direttamente di byte, soprattutto quando si tratta di 0.

EDIT: appena notato un altro. Se si utilizzano le strutture di dati esatte che si utilizzano per la versione non VBO (che ho assunto sopra), allora è necessario utilizzare sizeof(Vertex) come parametro di passo in glVertexPointer.

Answer 3

Come dichiarate vertici e indici?

Il parametro dimensione di glBufferData dovrebbe essere la dimensione del buffer in byte e se si passa sizeof (vertici) esso ritornerà la dimensione totale della matrice dichiarata (non solo ciò che è allocato).

Provare qualcosa di simile sizeof (Vertex) * numVertices e sizeof (indici [0]) * numIndices invece.