opengl => Utilizzo di VAO

introduzione

L'oggetto Vertex Array memorizza come opengl deve interpretare un insieme di VBO.

In sostanza ti permetterà di evitare di chiamare glVertexAttribPointer ogni volta che vuoi rendere una nuova mesh.

Se non vuoi trattare con VAO puoi semplicemente crearne uno e collegarlo durante l'inizializzazione del programma e far finta che non esistano.

Sintassi

void glEnableVertexAttribArray (GLuint attributIndex);
void glDisableVertexAttribArray (GLuint attributIndex);
void glVertexAttribPointer (GLInint attribIndex, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
void glVertexAttribFormat (attribuDex GLuint, dimensione GLint, tipo GLenum, normalizzazione GLboolean, offset relativo di GLuint);
void glVertexAttribBinding (GLuint attribIndex, GLuint bindingIndex);
void glBindVertexBuffer (GLuint bindingIndex, GLuint buffer, GLintptr offset, GLintptr stride);

Parametri

parametro	Dettagli
attribIndex	la posizione dell'attributo vertice a cui l'array vertice alimenterà i dati
taglia	il numero di componenti da estrarre dall'attributo
genere	Il tipo C ++ dei dati degli attributi nel buffer
normalizzato	se mappare i tipi interi nell'intervallo a virgola mobile [0, 1] (per i non firmati) o [-1, 1] (per i firmati)
pointer	l'offset del byte nel buffer del primo byte dei dati dell'attributo (cast a `void*` per motivi legacy)
compensare	l'offset del byte di base dall'inizio del buffer a cui iniziano i dati dell'array
relativeOffset	l'offset di un particolare attributo, relativo all'offset base per il buffer
passo	il numero di byte dai dati di un vertice al successivo
buffer	l'oggetto buffer in cui sono memorizzati gli array di vertici
bindingIndex	l'indice al quale verrà associato l'oggetto buffer di origine

Osservazioni

Il formato di attributo separato glVertexAttribPointer VAO può interagire con glVertexAttribPointer (quest'ultimo è definito in base al primo). Ma devi stare attento quando lo fai.

La versione del formato di attributo separato ha equivalenti di accesso diretto allo stato (DSA) in 4.5. Questi avranno gli stessi parametri ma invece di usare il VAO associato, il VAO che viene modificato viene passato esplicitamente. Quando si usa DSA de index buffer per glDrawElements può impostare con glVertexArrayElementBuffer(vao, ebo);

Versione 3.0

Ogni attributo è associato a un numero di componenti, tipo, normalizzato, offset, falcata e VBO. Il VBO non è passato esplicitamente come parametro ma è invece il buffer associato a GL_ARRAY_BUFFER al momento della chiamata.

void prepareMeshForRender(Mesh mesh){
    glBindVertexArray(mesh.vao);
    glBindBuffer(GL_ARRAY_BUFFER, mesh.vbo);
    
    glVertexAttribPointer (posAttrLoc, 3, GL_FLOAT, false, sizeof(Vertex), mesh.vboOffset + offsetof(Vertex, pos));//will associate mesh.vbo with the posAttrLoc
    glEnableVertexAttribArray(posAttrLoc);

    glVertexAttribPointer (normalAttrLoc, 3, GL_FLOAT, false, sizeof(Vertex), mesh.vboOffset + offsetof(Vertex, normal));
    glEnableVertexAttribArray(normalAttrLoc);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.ebo); //this binding is also saved.
    glBindVertexArray(0);
}

void drawMesh(Mesh[] meshes){
    foreach(mesh in meshes){        
        glBindVertexArray(mesh.vao);
        glDrawElements(GL_TRIANGLES, mesh.vertexCount, GL_UNSIGNED_INT, mesh.indexOffset);
    }
}

Versione 4.3

4.3

OpenGL 4.3 (o ARB_separate_attrib_format) aggiunge un modo alternativo di specificare i dati del vertice, creando una separazione tra il formato dei dati associati a un attributo e l'origine dell'oggetto buffer che fornisce i dati. Quindi, invece di avere un VAO per mesh, potresti avere un VAO per formato di vertice.

Ogni attributo è associato con un formato vertice e un punto di associazione. Il formato del vertice è costituito dal tipo, dal numero di componenti, dal fatto che sia normalizzato e dall'offset relativo dall'inizio del dato a quel particolare vertice. Il punto di legame specifica da quale buffer un attributo prende i suoi dati. Separando i due, è possibile associare i buffer senza rispettare i formati dei vertici. È anche possibile modificare il buffer che fornisce dati a più attributi con una singola chiamata di bind.

//accessible constant declarations
constexpr int vertexBindingPoint = 0;
constexpr int texBindingPoint = 1;// free to choose, must be less than the GL_MAX_VERTEX_ATTRIB_BINDINGS limit

//during initialization
glBindVertexArray(vao);

glVertexAttribFormat(posAttrLoc, 3, GL_FLOAT, false, offsetof(Vertex, pos));
// set the details of a single attribute
glVertexAttribBinding(posAttrLoc, vertexBindingPoint);
// which buffer binding point it is attached to
glEnableVertexAttribArray(posAttrLoc);

glVertexAttribFormat(normalAttrLoc, 3, GL_FLOAT, false, offsetof(Vertex, normal));
glVertexAttribBinding(normalAttrLoc, vertexBindingPoint);
glEnableVertexAttribArray(normalAttrLoc);

glVertexAttribFormat(texAttrLoc, 2, GL_FLOAT, false, offsetof(Texture, tex));
glVertexAttribBinding(texAttrLoc, texBindingPoint);
glEnableVertexAttribArray(texAttrLoc);

Quindi durante l'estrazione si mantiene vincolato il vao e si modificano solo i binding del buffer.

void drawMesh(Mesh[] mesh){
    glBindVertexArray(vao);

    foreach(mesh in meshes){
        glBindVertexBuffer(vertexBindingPoint, mesh.vbo, mesh.vboOffset, sizeof(Vertex));
        glBindVertexBuffer(texBindingPoint, mesh.texVbo, mesh.texVboOffset, sizeof(Texture));
        // bind the buffers to the binding point

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.ebo);

        glDrawElements(GL_TRIANGLES, mesh.vertexCount, GL_UNSIGNED_INT, mesh.indexOffset);
        //draw
    }
}

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

opengl
Utilizzo di VAO

Ricerca…