GLES20 Warum Texturdaten nicht mit Vertices-Indizes verknüpft sind?

Question

Ich habe versucht, einen Würfel zu rendern und eine einzige Textur auf allen Flächen anwenden. sowie so wenig Vertices wie ich kann, indem ich Indexe der Scheitelpunkte des Gesichts verlasse. Beispiel:

Vertices:

static final float FACE_VERTEX[] = { 
     // front 
     0.0f, 1.0f, 1.0f,  //0 
     0.0f, 0.0f, 1.0f,  //1 
     1.0f, 0.0f, 1.0f,  //2 
     1.0f, 1.0f, 1.0f,  //3 

     //back 
     1.0f, 1.0f, 0.0f,  //4 - 3 
     1.0f, 0.0f, 0.0f,  //5 - 2 
     0.0f, 0.0f, 0.0f,  //6 - 1 
     0.0f, 1.0f, 0.0f,  //7 - 0 
}; 

Indizes:

static final int FACE_INDEX[] = { 
     //front 
     0,1,2, 0,2,3, 
     //back 
     4,5,6, 4,6,7, 

     //left 
     7,6,1, 7,1,0, 

     //right 
     3,2,5, 3,5,4, 

     //top 
     4,7,0, 4,0,3, 

     //bottom 
     1,6,5, 1,5,2 

}; 

Texturabbildungsdaten:

final int textureCoordinateData[] = 
     { 
       // Front face 
       0,0, 0,1, 1,1, 1,0, 
       //back 
       0,0, 0,1, 1,1, 1,0, 
       //left 
       0,0, 0,1, 1,1, 1,0, 
       //right 
       0,0, 0,1, 1,1, 1,0, 
       //top 
       0,0, 0,1, 1,1, 1,0, 
       //bottom 
       0,0, 0,1, 1,1, 1,0, 
       //top 
       0,0, 0,1, 1,1, 1,0, 
       //bottom 
       0,0, 0,1, 1,1, 1,0, 


     }; 

Die Textur auf allen Seiten des Würfels wiedergegeben wird, mit der Ausnahme oberen und unteren .

I VBOs bin mit den Scheitelpunkt/index/Texturdaten in der GPU zu speichern: nur die erste Zeile der Bildpunkte der Vorderfläche ist entlang der gesamten oberen und unteren Flächen (siehe Abbildung) gerendert und dieses Problem jedoch mit

glDrawElements(GL_TRIANGLES, indexLength, GL_UNSIGNED_INT, 0); 

Rendering ist, weil die Texturdaten zu den übergebenen Vertex-Daten zugeordnet werden (was für ein Würfelmodell ein bisschen nervig ist) und wird nicht durch den Index berechnet.

Meine Fragen werden sein: - Gibt es eine Möglichkeit, die Daten der Scheitelpunkte so niedrig wie möglich zu halten und die Textur den Indexdaten zuzuordnen? - Wenn ich 36 Vertices (einige werden wiederholt) zur Lösung der Textur Mapping-Problem, aber ich habe die richtigen Indizes erstellt, um den Würfel zu rendern, wäre es immer noch schneller als mit glDrawArrays? Oder soll ich mit glDrawArrays gehen und die Indizierung Daten sowieso trash?

damit verbundene Frage (die nicht meine Frage beantworten):

OpenGL ES - texture map all faces of an 8 vertex cube?

Wenn Sie den ersten Kommentar über die Antwort lauten:

Was meinen Sie damit Sie 24 verwenden müssen Eckpunkte? Wenn Sie die Scheitelpunkte duplizieren müssen, was ist der Punkt der Verwendung eines Indexpuffers dann, wenn Sie immer noch Daten an die GPU senden?

Answer 1

Es gibt wirklich keinen vernünftigen Weg, einen Würfel mit Texturkoordinaten mit weniger als 24 Ecken zu zeichnen. Das liegt daran, dass ... 24 Eckpunkte vorhanden sind, wenn die Definition dessen verwendet wird, was einen Eckpunkt in OpenGL bildet, also jede eindeutige Kombination von Eckpunktattributen (Position, Texturkoordinaten, Normal usw.).

Sie können die Zahl möglicherweise nur geringfügig mit Positionen und Texturkoordinaten reduzieren, da die Texturkoordinaten in Ihrem Fall nur Kombinationen von 0 und 1 Werten sind. Wenn Sie sich nicht um die Ausrichtung der Textur auf jeder Fläche kümmern, könnten Sie beispielsweise einen Stützpunkt haben, der (0, 0) für die Texturkoordinaten aller 3 angrenzenden Flächen verwendet. Natürlich können Sie das nicht für alle Stützpunkte tun, aber Sie könnten die Anzahl der Stützpunkte etwas reduzieren.

Also ist die Verwendung von Indizes es wert?Wie Sie bereits festgestellt haben, können Sie bei Verwendung von Indizes problemlos 24 Eckpunkte beibehalten, benötigen aber 36 Eckpunkte mit der einfachsten Verwendung von glDrawArrays(), wobei Sie einen einfachen Zeichenaufruf mit GL_TRIANGLES als primitiven Typ verwenden. Es reduziert also die Anzahl der Scheitelpunkte.

Sie können es auch auf 24 Vertices mit glDrawArrays() reduzieren, wenn Sie für jedes Gesicht einen separaten Zeichenaufruf machen und das Gesicht mit dem primitiven Typ GL_TRIANGLE_STRIP mit jeweils 4 Scheitelpunkten zeichnen. Dies wird jedoch zu 6 Zeichenaufrufen führen, und viele kleine Zeichenaufrufe sind auch nicht wünschenswert.

Auch wenn es im Falle eines Würfels fragwürdig erscheinen mag, sind Indexpuffer im Allgemeinen sehr nützlich. Ein Würfel ist so eine kleine und einfache Form, dass die Art, wie Sie die Scheitelpunkte senden, keinen großen Unterschied macht.

In den meisten Anwendungsfällen haben Sie viel komplexere Formen, mit vielen weiteren Ecken, die oft glatte Oberflächen definieren. In diesem Fall wird derselbe Eckpunkt (mit den gleichen Normal- und Texturkoordinaten) meistens von mehreren Dreiecken geteilt. Skizzieren eines Teils eines regulären Netzes:

Sie können sehen, dass die inneren Vertices von jeweils 6 Dreiecken geteilt werden. Für eine relativ große, glatte Oberfläche können Sie die Anzahl der Scheitelpunkte normalerweise um einen Faktor von 6 reduzieren, indem Sie die Scheitelpunkte gemeinsam verwenden. Dies ermöglicht Ihnen die Verwendung eines Indexarrays. Die Reduzierung der Speicherauslastung um fast den Faktor 6 kann einen erheblichen Gewinn bedeuten, wenn Ihre Geometrie ausreichend groß ist.