Textur-UVs werden nicht korrekt an Shader gesendet

Question

Ich rendere ein Mesh mit GLSL-Shadern und einem VBO, und der VBO speichert 4 Attribute; positionXYZ, normalXYZ, TexturUV, FarbeRGBA. Alles funktioniert, bis auf die UVs (möglicherweise auch die Normalen, aber ich habe noch keine Möglichkeit, sie zu testen).

Was geschieht, ist, dass die UV-Texturpositionen im Array zur normalen x- und y-Position im Array versetzt sind. Das Array ist übrigens als VVVNNNTTCCCC (Vertexposition, normal, Textur, Farbe) strukturiert. Ich bin mir ziemlich sicher, dass das Problem darin besteht, den VBO an die Shader zu senden. Ich weiß mit Sicherheit, dass die Daten in der VBO in der richtigen Reihenfolge sind.

Dies ist meine Rendering-Code:

Die VBO Klasse

public final class Mesh 
{ 
    public static final int FLOAT_SIZE_BYTES = 4; 
    public static final int FLOATS_PER_POSITION = 3; 
    public static final int FLOATS_PER_NORMAL = 3; 
    public static final int FLOATS_PER_TEXTURE = 2; 
    public static final int FLOATS_PER_COLOUR = 4; 
    public static final int VERTEX_SIZE_FLOATS = FLOATS_PER_POSITION + FLOATS_PER_NORMAL + FLOATS_PER_TEXTURE + FLOATS_PER_COLOUR; 
    public static final int VERTEX_SIZE_BYTES = VERTEX_SIZE_FLOATS * FLOAT_SIZE_BYTES; 

    public static final int POSITION_OFFSET_FLOATS = 0; 
    public static final int NORMAL_OFFSET_FLOATS = POSITION_OFFSET_FLOATS + FLOATS_PER_POSITION; 
    public static final int TEXTURE_OFFSET_FLOATS = NORMAL_OFFSET_FLOATS + FLOATS_PER_NORMAL; 
    public static final int COLOUR_OFFSET_FLOATS = TEXTURE_OFFSET_FLOATS + FLOATS_PER_TEXTURE; 
    public static final int POSITION_OFFSET_BYTES = POSITION_OFFSET_FLOATS * FLOAT_SIZE_BYTES; 
    public static final int NORMAL_OFFSET_BYTES = NORMAL_OFFSET_FLOATS * FLOAT_SIZE_BYTES; 
    public static final int TEXTURE_OFFSET_BYTES = TEXTURE_OFFSET_FLOATS * FLOAT_SIZE_BYTES; 
    public static final int COLOUR_OFFSET_BYTES = COLOUR_OFFSET_FLOATS * FLOAT_SIZE_BYTES; 
    public static final int POSITION_STRIDE_BYTES = VERTEX_SIZE_BYTES; 
    public static final int NORMAL_STRIDE_BYTES = VERTEX_SIZE_BYTES; 
    public static final int TEXTURE_STRIDE_BYTES = VERTEX_SIZE_BYTES; 
    public static final int COLOUR_STRIDE_BYTES = VERTEX_SIZE_BYTES; 

    public final static int VERTICES_PER_FACE = 3; 

    public static final int ATTRIBUTE_LOCATION_POSITION = 0; 
    public static final int ATTRIBUTE_LOCATION_NORMAL = 1; 
    public static final int ATTRIBUTE_LOCATION_TEXTURE = 2; 
    public static final int ATTRIBUTE_LOCATION_COLOUR = 3; 

    private int vaoID; 
    private int iboID; 
    private int indexCount; 

    private Mesh(int vaoID, int iboID, int indexCount) 
    { 
     this.vaoID = vaoID; 
     this.iboID = iboID; 
     this.indexCount = indexCount; 
    } 

    public void draw(AbstractShaderProgram shader, Texture texture) 
    { 
     glEnable(GL_TEXTURE_2D); 
     if (texture != null) texture.bind(shader); 
     else Texture.MISSING_TEXTURE.bind(shader); 

     glBindVertexArray(vaoID); 
     glEnableVertexAttribArray(ATTRIBUTE_LOCATION_POSITION); 
//  glEnableVertexAttribArray(ATTRIBUTE_LOCATION_NORMAL); 
//  glEnableVertexAttribArray(ATTRIBUTE_LOCATION_TEXTURE); 
//  glEnableVertexAttribArray(ATTRIBUTE_LOCATION_COLOUR); 

     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboID); 
     glDrawElements(GL_TRIANGLES, indexCount, GL_FLOAT, 0); 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 

     glDisableVertexAttribArray(ATTRIBUTE_LOCATION_POSITION); 
//  glDisableVertexAttribArray(ATTRIBUTE_LOCATION_NORMAL); 
//  glDisableVertexAttribArray(ATTRIBUTE_LOCATION_TEXTURE); 
//  glDisableVertexAttribArray(ATTRIBUTE_LOCATION_COLOUR); 

     glBindVertexArray(0); 

     glDisable(GL_TEXTURE_2D); 
    } 

    public static Mesh compile(List<Face> faces) 
    { 
     if (faces.size() <= 0) 
      throw new RuntimeException("Failed to compile mesh. No faces were provided."); 

     HashMap<Vertex, Integer> indexMap = new HashMap<>(); 
     ArrayList<Vertex> vertices = new ArrayList<>(); 
     int vertexCount = 0; 


     for (Face face : faces) 
     { 
      for (Vertex vertex : face.getVertices()) 
      { 
       if (!indexMap.containsKey(vertex)) 
       { 
        indexMap.put(vertex, vertexCount++); 
        vertices.add(vertex); 
       } 
      } 
     } 

     int indicesCount = faces.size() * VERTICES_PER_FACE; 

     int dataSize = vertexCount * VERTEX_SIZE_FLOATS; 
     FloatBuffer vertexData = BufferUtils.createFloatBuffer(dataSize); 
     if (vertexData == null) 
      System.err.println("Failed to allocate FloatBuffer with size " + dataSize); 

     for (Vertex vertex : vertices) 
     { 
      vertexData.put(vertex.getPosition().x); 
      vertexData.put(vertex.getPosition().y); 
      vertexData.put(vertex.getPosition().z); 
//   vertexData.put(vertex.getNormal() == null ? 1.0F : vertex.getNormal().x); 
//   vertexData.put(vertex.getNormal() == null ? 1.0F : vertex.getNormal().y); 
//   vertexData.put(vertex.getNormal() == null ? 1.0F : vertex.getNormal().z); 
//   vertexData.put(vertex.getTexture() == null ? 0.0F : vertex.getTexture().x); 
//   vertexData.put(vertex.getTexture() == null ? 0.0F : vertex.getTexture().y); 
//   vertexData.put(vertex.getColour() == null ? 1.0F : vertex.getColour().getRGBA().x); 
//   vertexData.put(vertex.getColour() == null ? 1.0F : vertex.getColour().getRGBA().y); 
//   vertexData.put(vertex.getColour() == null ? 1.0F : vertex.getColour().getRGBA().z); 
//   vertexData.put(vertex.getColour() == null ? 1.0F : vertex.getColour().getRGBA().w); 
     } 
     vertexData.flip(); 

     IntBuffer indices = BufferUtils.createIntBuffer(indicesCount); 

     for (Face face : faces) 
     { 
      for (Vertex vertex : face.getVertices()) 
      { 
       int index = indexMap.get(vertex); 
       indices.put(index); 
      } 
     } 
     indices.flip(); 

     int vaoID = glGenVertexArrays(); 
     glBindVertexArray(vaoID); 

     int vboID = glGenBuffers(); 
     glBindBuffer(GL_ARRAY_BUFFER, vboID); 

     glBufferData(GL_ARRAY_BUFFER, vertexData, GL_STATIC_DRAW); 

     glVertexAttribPointer(ATTRIBUTE_LOCATION_POSITION, FLOATS_PER_POSITION, GL_FLOAT, false, 0, 0); 
//  glVertexAttribPointer(ATTRIBUTE_LOCATION_NORMAL, FLOATS_PER_NORMAL, GL_FLOAT, false, NORMAL_STRIDE_BYTES, NORMAL_OFFSET_BYTES); 
//  glVertexAttribPointer(ATTRIBUTE_LOCATION_TEXTURE, FLOATS_PER_TEXTURE, GL_FLOAT, false, TEXTURE_STRIDE_BYTES, TEXTURE_OFFSET_BYTES); 
//  glVertexAttribPointer(ATTRIBUTE_LOCATION_COLOUR, FLOATS_PER_COLOUR, GL_FLOAT, false, COLOUR_STRIDE_BYTES, COLOUR_OFFSET_BYTES); 

     glBindBuffer(GL_ARRAY_BUFFER, 0); 
     glBindVertexArray(0); 

     int iboID = glGenBuffers(); 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboID); 
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices, GL_STATIC_DRAW); 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 

     return new Mesh(vaoID, iboID, indicesCount); 
    } 
} 

Der Vertex-Shader:

#version 400 core 

in vec3 vertPosition; 
in vec3 vertNormal; 
in vec2 vertTexture; 
in vec4 vertColour; 

uniform mat4 projectionMatrix; 
uniform mat4 viewMatrix; 
uniform mat4 modelMatrix; 

out vec3 pVertPosition; 
out vec3 pVertNormal; 
out vec2 pVertTexture; 
out vec4 pVertColour; 

void main() 
{ 
    pVertPosition = vertPosition; 
    pVertNormal = vertNormal; 
    pVertTexture = vertTexture; 
    pVertColour = vertColour; 

    gl_Position = vec4(vec3(vertPosition.xy + vertTexture, vertPosition.z), 1.0); 
} 

Das Fragment-Shader:

#version 400 core 

in vec3 ppVertPosition; 
in vec3 ppVertNormal; 
in vec2 ppVertTexture; 
in vec4 ppVertColour; 

uniform sampler2D texture; 

void main() 
{ 
    gl_FragColor = texture2D(texture, ppVertTexture); 
} 

Es gibt eine Geometrie Shader in zwischen diesen, aber es ist derzeit redundant und pases die Informationen direkt auf den Fragment-Shader (deshalb stimmen die out und in Variablen nicht überein.) Auch der Grund, dass die TexturUV der Vertex-Position im Fragment-Shader hinzugefügt wurde, war um zu debuggen, was die UV-Werte der Textur tatsächlich waren. So weiß ich, dass die UVs zum normalen xy versetzt sind. Wenn ich die Textur UVs in das normale xy setze, funktionieren sie perfekt.

Wenn es einen zusätzlichen Code gibt, den Sie sehen möchten, den ich nicht eingeschlossen habe, füge ich ihn hinzu. Ich habe nicht alles hinzugefügt, zum Beispiel die ganze VBO-Klasse, weil es zu viel Code ist. Ich habe nur das hinzugefügt, was ich für relevant halte und wo ich das Problem vermute.

Bearbeiten # 1: Die Variablenpositionen im Shader, wie vertPosition und vertNormal sind gebunden. Dies ist mein Code sie

glBindAttribLocation(program, Mesh.ATTRIBUTE_LOCATION_POSITION, "vertPosition"); 
glBindAttribLocation(program, Mesh.ATTRIBUTE_LOCATION_NORMAL, "vertNormal"); 
glBindAttribLocation(program, Mesh.ATTRIBUTE_LOCATION_TEXTURE, "vertTexture"); 
glBindAttribLocation(program, Mesh.ATTRIBUTE_LOCATION_COLOUR, "vertColour"); 

Ändern der Vertex-Shader zu binden Layouts zu verwenden, wie so, die ex \ ct gleiche Ergebnis liefert;

layout(location = 0) in vec3 vertPosition; 
layout(location = 1) in vec3 vertNormal; 
layout(location = 2) in vec2 vertTexture; 
layout(location = 3) in vec4 vertColour; 

Edit # 2 ich beschlossen, die gesamte Mesh-Klasse zu schreiben, anstatt nur Teile davon. Ich habe auch versucht, VAOs anstelle von VBOs zu implementieren, aber es funktioniert nicht.

Answer 1

Sie mischen Standard-Pipeline-Funktionalität mit benutzerdefinierten Shader-Variablen.

Aufruf glEnableClientState(GL_VERTEX_ARRAY); teilt OpenGL mit einem bestimmten Datenbindungspunkt, alles gut.

Aufruf glVertexPointer( teilt OpenGL mit, wo seine Vertices zu finden sind. Da Sie zuvor das richtige Array aktiviert haben, ist alles noch gut.

Dann kommen wir zum Vertex-Shader und Sie verwenden in vec3 vertPosition; aber GLSL weiß nicht, dass Sie Ihre Scheitelpunktdaten dort wollen. Sicher, wir können sehen, dass der Name "vertPosition" ist, aber GLSL sollte die Daten, die Sie wollen, natürlich nicht basierend auf dem Variablennamen erraten müssen! Das Standard-Pipeline-Verhalten für GLSL ist stattdessen gl_Vertex, eine vordefinierte GLSL-Variable, die an GL_VERTEX_ARRAY gebunden ist.

Warum funktioniert es für Positionen? Ich schätze, Sie haben Glück, dass die Variablen, die Sie definieren, zufälligerweise die vordefinierten Konstanten zugewiesen bekommen.

Was Sie tun sollten, ist glEnableClientState zu glEnableVertexAttribArray wechseln, verwenden Sie Layouts jeder Variablen eine Nummer zuweisen, und rufen glVertexAttribPointer statt glVertexPointer diese Zahl auf die richtigen Daten zu verknüpfen.

Nun zeigen die Variablen, die Sie deklariert haben, wie vertPosition, auf die richtigen Daten in Ihren Puffern, nicht zufällig, sondern weil Sie es ihnen gesagt haben!

Dies ist der richtige Weg, Dinge in modernen OpenGL zu tun, mit den vorgefertigten Variablen wie gl_Vertex und Funktionen wie glEnableClientState gilt als alt und schlecht, weil es unflexibel ist.

Sie können auch die Layouts weglassen (weil es OGL 4+ benötigt, was nicht jeder hat), aber das erfordert etwas mehr Arbeit, bevor die Shader verlinkt werden.

Viel Glück!

More info on converting your code

(Ich hoffe, im Recht mit diesem, kann ich nicht kommentieren, um tatsächlich zu überprüfen, dass dies das Problem)

Answer 2

Okay, ich habe es funktioniert ... endlich. Ich habe keine Ahnung, was das anfängliche Problem mit der VBO war, aber sobald ich wechselte, um einen VAO zu verwenden, und nicht mit glClientState zu rendern, funktionierte es gut. Auch das Problem, das ich hatte mit dem VAO nichts machen, was so überhaupt war die Zeile:

glDrawElements(GL_TRIANGLES, indexCount, GL_FLOAT, 0); 

sollte

glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);