sfarfallio di opengl durante il rendering di più oggetti

Question

Sono abbastanza nuovo su Opengl e non capisco cosa sta succedendo qui. Sto cercando di utilizzare due VAO per creare oggetti multipli e sto usando una matrice personalizzata per ruotarli/tradurli. L'immagine va bene quando ne carico uno, ma quando carico due lampeggiano entrambi. Il mio init è questo, dove ho una matrice diversa per ciascun buffer, posizione dei vertici, indici dei vertici e colori dei vertici.

void init() 
{ 
readFile(); 
//glEnable(GL_DEPTH); 
glEnable(GL_DEPTH_TEST); 
//make background yerpul in colour 
glClearColor(0.235, 0.194, 0.314, 1.0); 


    // Load shaders and use the resulting shader program 
    program = InitShader("aVertexShader61.glsl", "aFragShader61.glsl"); 
    glUseProgram(program); 

    // Create a vertex array object 
    glGenVertexArrays(1, &vao); 
    glBindVertexArray(vao); 

    // Create and initialize two buffer objects 
    glGenBuffers(2, buffers); 

    //one buffer for the vertexPositions and colours 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); 
    glBufferData(GL_ARRAY_BUFFER, numVertexPositionBytes + numVertexColourBytes,NULL, GL_STATIC_DRAW); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions); 
    glBufferSubData(GL_ARRAY_BUFFER, numVertexPositionBytes, numVertexColourBytes, vertexColours); 

    //one buffer for the indices 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numVertexIndexBytes,vertexIndicies, GL_STATIC_DRAW); 

    // set up vertex arrays 
    GLuint vPosition = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition); 
    glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); 

    GLuint vColor = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor); 
    glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(numVertexPositionBytes)); 

    // Second object 

    glGenVertexArrays(1, &vao2); 
    glBindVertexArray(vao2); 

    glGenBuffers(2, buffers2); 

    //one buffer for the vertexPositions and colours 
    glBindBuffer(GL_ARRAY_BUFFER, buffers2[0]); 
    glBufferData(GL_ARRAY_BUFFER, numVertexPositionBytes + numVertexColourBytes,NULL, GL_STATIC_DRAW); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions2); 
    glBufferSubData(GL_ARRAY_BUFFER, numVertexPositionBytes, numVertexColourBytes, vertexColours2); 

    //one buffer for the indices 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers2[1]); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numVertexIndexBytes,vertexIndicies2, GL_STATIC_DRAW); 

    // set up vertex arrays 
    GLuint vPosition2 = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition2); 
    glVertexAttribPointer(vPosition2, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); 

    GLuint vColor2 = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor2); 
    glVertexAttribPointer(vColor2, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(numVertexPositionBytes)); 


    glBindVertexArray(0); 
} 

Questo è il mio display che viene chiamato con glutPostRedisplay(); nella mia funzione di inattività, nessun'altra chiamata a qualcosa viene effettuata dal minimo. mStack è un oggetto matrix stack creato da un file esterno

void 
    display(void) 
{ 

    //clear for first object, generate matrix and apply to object 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    mStack.loadIdentity(); 
    mStack.translatef(0,yDisplace,0); 
    mStack.rotatef(Theta[Yaxis], 0.0,1.0,0.0); 
    for (unsigned char i=0; i<NumVertices; i++){ 
     mStack.transformf(&vertexPositionsInit[i*4],&vertexPositions[i*4]); 

    } 

    //Apply to second object 
    for (unsigned char i=0; i<NumVertices; i++){ 
     mStack.transformf(&vertexPositionsInit2[i*4],&vertexPositions2[i*4]); 

    } 


    //Draw first object 
    glBindVertexArray(vao); 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 
    //Indexing into vertices we need to use glDrawElements 
    glDrawElements(GL_TRIANGLES, NumIndicies, GL_UNSIGNED_BYTE, 0); 
    glutSwapBuffers(); 


    //Clear and draw second object 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glutSwapBuffers(); 
    glBindVertexArray(vao2); 
    glBindBuffer(GL_ARRAY_BUFFER, buffers2[0]); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, numVertexPositionBytes, vertexPositions2); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers2[1]); 
    //Indexing into vertices we need to use glDrawElements 
    glDrawElements(GL_TRIANGLES, NumIndicies, GL_UNSIGNED_BYTE, 0); 
    glutSwapBuffers(); 


} 

Sto usando semplici vertici e frammenti di shader. Il vertex shader,

in vec4 vPosition; 
in vec4 vColor; 
out vec4 color; 

void main() 
{ 
    gl_Position = vPosition; 
    color = vColor; 
} 

E frammento di shader,

in vec4 color; 
out vec4 fColor; 

void main() 
{ 
    fColor = color; 
} 

Qualsiasi aiuto sarebbe apprezzato, e posso inviare il file di Matrix, se necessario. Grazie

Answer 1

Non chiamare glutSwapBuffers() o glClear() tra gli oggetti. Scambiare i buffer è un modo per dire a GLUT "Ok, ho finito con questo frame, iniziamo con il prossimo".

Di solito si vorrà dividere il codice che imposta e completa ogni fotogramma (come le chiamate a glClear() e glutSwapBuffers()) dal codice che rende ogni oggetto, perché OpenGL è fondamentalmente una gigantesca scatola di variabili globali ed è difficile scrivere bene il codice OpenGL senza rompere i metodi in piccoli pezzi.