Problème lors de l'utilisation de shaders simples + VBOs

Question

Bonjour J'essaie de convertir les fonctions suivantes en une fonction basée sur VBO à des fins d'apprentissage, elle affiche une texture statique à l'écran. J'utilise OpenGL ES 2.0 avec les shaders sur l'iPhone (qui devrait être à peu près la même que OpenGL régulière dans ce cas), ce que je suis arrivé à travailler:

//Works! 
- (void) drawAtPoint:(CGPoint)point depth:(CGFloat)depth 
{ 
    GLfloat    coordinates[] = { 
          0,   1, 
          1,   1, 
          0,   0, 
          1,   0 
         }; 

    GLfloat    width = (GLfloat)_width * _maxS, 
         height = (GLfloat)_height * _maxT; 

    GLfloat    vertices[] = { 
          -width/2 + point.x,  -height/2 + point.y, 
          width/2 + point.x,  -height/2 + point.y, 
          -width/2 + point.x,  height/2 + point.y, 
          width/2 + point.x,  height/2 + point.y, 
         }; 


    glBindTexture(GL_TEXTURE_2D, _name); 
    //Attrib position and attrib_tex coord are handles for the shader attributes 
    glVertexAttribPointer(ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices); 
    glEnableVertexAttribArray(ATTRIB_POSITION); 
    glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, coordinates); 
    glEnableVertexAttribArray(ATTRIB_TEXCOORD); 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 
} 

J'ai essayé de le faire pour convertir en VBO Je ne vois cependant rien afficher à l'écran avec cette version:

//Doesn't display anything 
- (void) drawAtPoint:(CGPoint)point depth:(CGFloat)depth 
{ 
    GLfloat    width = (GLfloat)_width * _maxS, 
         height = (GLfloat)_height * _maxT; 

    GLfloat    position[] = { 
          -width/2 + point.x,  -height/2 + point.y, 
          width/2 + point.x,  -height/2 + point.y, 
          -width/2 + point.x,  height/2 + point.y, 
          width/2 + point.x,  height/2 + point.y, 
         }; //Texture on-screen position (each vertex is x,y in on-screen coords) 

    GLfloat    coordinates[] = { 
     0,   1, 
     1,   1, 
     0,   0, 
     1,   0 
    }; // Texture coords from 0 to 1 

    glBindVertexArrayOES(vao); 
    glGenVertexArraysOES(1, &vao); 
    glGenBuffers(2, vbo); 

    //Buffer 1 
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); 
    glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), position, GL_STATIC_DRAW); 
    glEnableVertexAttribArray(ATTRIB_POSITION); 
    glVertexAttribPointer(ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, position); 

    //Buffer 2 
    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); 
    glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), coordinates, GL_DYNAMIC_DRAW);  
    glEnableVertexAttribArray(ATTRIB_TEXCOORD); 
    glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, coordinates); 

    //Draw 
    glBindVertexArrayOES(vao); 
    glBindTexture(GL_TEXTURE_2D, _name); 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 
} 

Dans les deux cas j'utilise ce simple Vertex Shader

//Vertex Shader 
attribute vec2 position;//Bound to ATTRIB_POSITION 
attribute vec4 color; 
attribute vec2 texcoord;//Bound to ATTRIB_TEXCOORD 

varying vec2 texcoordVarying; 

uniform mat4 mvp; 

void main() 
{ 
    //You CAN'T use transpose before in glUniformMatrix4fv so... here it goes. 
    gl_Position = mvp * vec4(position.x, position.y, 0.0, 1.0); 
    texcoordVarying = texcoord; 
} 

Le gl_Position est égal au produit de mvp * vec4 parce que je suis simulant glOrthof en 2D avec cette mvp

Et ce fragment Shader

//Fragment Shader 
uniform sampler2D sampler; 

varying mediump vec2 texcoordVarying; 

void main() 
{ 
    gl_FragColor = texture2D(sampler, texcoordVarying); 
} 

J'ai vraiment besoin d'aide pour cela, peut-être mes shaders sont mauvais pour le second cas?

merci d'avance.

Answer 1

Tout est correct, sauf l'appel glVertexAttribPointer. Lorsque vous avez une liaison VBO, le dernier paramètre o glVertexAttribPointer est utilisé comme un décalage dans le VBO, comme un pointeur (la valeur du pointeur est le décalage). Donc, vos données sont au début de la VBO, donc le dernier paramètre devrait être 0 (NULL) pour les deux appels.