La unión de textura con VBO no funciona correctamente

Question

el propósito de mi programa es mostrar 2 cuadrículas con 2 texturas diferentes. El problema es que la textura más antigua cargada se establece en los dos cuatrillos (solo texQuadB). Traté de reemplazar las dos llamadas de buf [3] por texQuadA y texQuadB pero no funciona. No puedo encontrar la forma correcta de enlazar una textura con un VBO específico.

#define OFFSET_BUFFER(bytes) ((GLfloat *)NULL + bytes) 

GLfloat verticesQuadA[12] = 
{ 
    -1.0f, 0.0f, 1.0f, 
    -1.0f, 1.0f, 1.0f, 
    0.0f, 1.0f, 1.0f, 
    0.0f, 0.0f, 1.0f, 
}; 

GLfloat verticesQuadB[12] = 
{ 
    0.0f, 0.0f, 1.0f, 
    0.0f, 1.0f, 1.0f, 
    1.0f, 1.0f, 1.0f, 
    1.0f, 0.0f, 1.0f, 
}; 

GLfloat colors[12] = 
{ 
    1.0f, 0.0f, 0.0f, 
    0.0f, 1.0f, 0.0f, 
    0.0f, 0.0f, 1.0f, 
    1.0f, 0.0f, 1.0f, 
}; 

GLfloat texture[8] = 
{ 
    0.0f, 0.0f, 
    1.0f, 0.0f, 
    1.0f, 1.0f, 
    0.0f, 1.0f 
}; 

int main(int argc, char *argv[]) 
{ 
    SDL_Init(SDL_INIT_VIDEO); 
    SDL_WM_SetCaption("Texture Mapping",NULL); 
    SDL_SetVideoMode(500, 500, 32, SDL_OPENGL); 

    bool continuer = true; 
    SDL_Event event; 
    GLuint buf[4]; 
    GLuint texQuadA, texQuadB; 

    glClearDepth(1.0f); 
    glClearColor(0.1f, 0.1f, 0.1f, 0.1f); 
    glEnable(GL_DEPTH_TEST); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluPerspective(70.0f, (float)500.0f/(float)500.0f, 1.0f, 3000.0f); 
    glewInit(); 

    texQuadA = loadTexture("caisse.jpg"); 
    texQuadB = loadTexture("metal.jpg"); 

    //glBindTexture(GL_TEXTURE_2D, texQuadA); 
    //glBindTexture(GL_TEXTURE_2D, texQuadB); 

    glGenBuffers(4, buf); 

    glBindBuffer(GL_ARRAY_BUFFER, buf[0]); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(verticesQuadA), verticesQuadA, GL_STATIC_DRAW); 

    glBindBuffer(GL_ARRAY_BUFFER, buf[1]); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(verticesQuadB), verticesQuadB, GL_STATIC_DRAW); 

    glBindBuffer(GL_ARRAY_BUFFER, buf[2]); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW); 

    glBindBuffer(GL_ARRAY_BUFFER, buf[3]); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(texture), texture, GL_STATIC_DRAW); 

    while (continuer) 
    { 
     SDL_WaitEvent(&event); 
     switch(event.type) 
     { 
      case SDL_QUIT: 
       continuer = false; 
     } 

     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

     glEnable(GL_TEXTURE_2D); 

     glMatrixMode(GL_MODELVIEW); 
     glLoadIdentity(); 

     gluLookAt(0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); 

     //Draw Quad A --------------------------------------- 

     glBindBuffer(GL_ARRAY_BUFFER, buf[0]); 
     glVertexPointer(3, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glBindBuffer(GL_ARRAY_BUFFER, buf[2]); 
     glColorPointer(3, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glBindBuffer(GL_ARRAY_BUFFER, buf[3]); 
     glTexCoordPointer(2, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glEnableClientState(GL_VERTEX_ARRAY); 
     glEnableClientState(GL_COLOR_ARRAY); 
     glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

     glDrawArrays(GL_QUADS, 0, 4); 

     glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     glDisableClientState(GL_COLOR_ARRAY); 
     glDisableClientState(GL_VERTEX_ARRAY); 

     //Draw Quad B --------------------------------------- 

     glBindBuffer(GL_ARRAY_BUFFER, buf[1]); 
     glVertexPointer(3, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glBindBuffer(GL_ARRAY_BUFFER, buf[2]); 
     glColorPointer(3, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glBindBuffer(GL_ARRAY_BUFFER, buf[3]); 
     glTexCoordPointer(2, GL_FLOAT, 0, OFFSET_BUFFER(0)); 

     glEnableClientState(GL_VERTEX_ARRAY); 
     glEnableClientState(GL_COLOR_ARRAY); 
     glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

     glDrawArrays(GL_QUADS, 0, 4); 

     glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     glDisableClientState(GL_COLOR_ARRAY); 
     glDisableClientState(GL_VERTEX_ARRAY); 

     //---------------------------------------------------- 

     glFlush(); 
     SDL_GL_SwapBuffers(); 
    } 
    glDeleteBuffers(3, buf); 
    glDisable(GL_TEXTURE_2D); 
    SDL_Quit(); 

    return 0; 
} 

Answer 1

OpenGL es una máquina de estado. Encuadernar una textura es establecer parte de ese estado. Cuando las texturas están habilitadas, OpenGL usará el estado actual de la textura (la última textura que enlazó) cuando vaya a dibujar la geometría. Antes de dibujar Quad A, enlace texQuadA. Antes de dibujar el Quad B, enlace texQuadB:

glBindTexture(GL_TEXTURE_2D, texQuadA); 
// Draw Quad A 

glBindTexture(GL_TEXTURE_2D, texQuadB); 
// Draw Quad B 

En este caso, los VBO no están relacionados.

Answer 2

Los VBO no interactúan con los objetos de textura. Encuadernar un VBO no lo asocia a una textura.

Para seleccionar qué textura quieres usar para dibujar, llama a glBindTexture antes de ejecutar los comandos de dibujo utilizándolo.