Textur wird als schwarzes Viereck gerendert

Question

Ich habe versucht, die code wie in this tutorial on OpenGL3+ textures angegeben zu folgen, aber mein Ergebnis endet schwarz statt der Textur.

I stbimage bin mit dem Bild der Textur verwendet in eine direkte ByteBuffer zu laden und kann die RGB-Daten garantieren in dem Puffer ist, zumindest nicht einheitlich - so ist es nicht, dass sein kann.

Ich mag es normalerweise nicht, Code zu dumpen, aber ich sehe nicht viel anderes, was ich an dieser Stelle tun kann. Hier ist mein Java-Code und Shadern:

GL ist eine Schnittstelle zeigt auf allen GL ## Funktionalität in LWJGL3 .

ShaderProgram wickelt alle shaderspezifischen Sachen in eine nette Blackbox, die beim ersten Aufruf von use(GL) ein Shaderprogramm von den angehängten Shadern erzeugt und dieses Programm anschließend wieder verwendet. Das funktioniert gut für das Rendern eines farbigen Dreiecks, also schließe ich Fehler dort aus.

Util.checkError(GL, boolean); sucht nach OpenGL-Fehlern, die seit der letzten Ausführung aufgetreten sind, und löst eine Laufzeitausnahme aus, wenn der Boolesche Wert nicht gesetzt ist (wird stattdessen still in das Protokoll geschrieben, falls gesetzt).

_{Die Rendering-Code, Update (GL, lang) wird jeder Frame}

private static final ResourceAPI res = API.get(ResourceAPI.class); 

Image lwjgl32; 

ShaderProgram prog = new ShaderProgram(); 
int vbo, vao, ebo; 
int texture; 

@Override 
public void init(GL gl) { 

    try { 
     prog.attach(res.get("shaders/texDemo.vert", ShaderSource.class)); 
     prog.attach(res.get("shaders/texDemo.frag", ShaderSource.class)); 
     lwjgl32 = res.get("textures/lwjgl32.png", Image.class); 
    } catch(ResourceException e) { 
     throw new RuntimeException(e); 
    } 

    float[] vertices = { 
     // positions   // colors   // texture coords 
     0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top right 
     0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom right 
     -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom left 
     -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // top left 
    }; 

    int[] indices = { 
     0, 1, 3, // first triangle 
     1, 2, 3 // second triangle 
    }; 

    vao = gl.glGenVertexArrays(); 
    vbo = gl.glGenBuffers(); 
    ebo = gl.glGenBuffers(); 

    gl.glBindVertexArray(vao); 

    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo); 
    gl.glBufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW); 

    gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ebo); 
    gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indices, GL.GL_STATIC_DRAW); 

    gl.glVertexAttribPointer(0, 3, GL.GL_FLOAT, false, 8 * Float.BYTES, 0); 
    gl.glEnableVertexAttribArray(0); 

    gl.glVertexAttribPointer(1, 3, GL.GL_FLOAT, false, 8 * Float.BYTES, 3 * Float.BYTES); 
    gl.glEnableVertexAttribArray(0); 

    gl.glVertexAttribPointer(2, 2, GL.GL_FLOAT, false, 8 * Float.BYTES, 6 * Float.BYTES); 
    gl.glEnableVertexAttribArray(0); 

    texture = gl.glGenTextures(); 
    gl.glBindTexture(GL.GL_TEXTURE_2D, texture); 

    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); 
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); 

    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT); 
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT); 

    gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB8, lwjgl32.getWidth(), lwjgl32.getHeight(), 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, lwjgl32.getImageData()); 
    gl.glGenerateMipmap(GL.GL_TEXTURE_2D); 

    prog.use(gl); 
    gl.glUniform1i(gl.glGetUniformLocation(prog.getId(gl), "texture"), 0); 

    Util.checkError(gl, false); 
} 

@Override 
protected void update(GL gl, long deltaFrame) { 
    gl.glClearColor(0.2f, 0.3f, 0.3f, 1.0f); 
    gl.glClear(GL.GL_COLOR_BUFFER_BIT); 

    gl.glActiveTexture(GL.GL_TEXTURE0); 
    gl.glBindTexture(GL.GL_TEXTURE_2D, texture); 

    prog.use(gl); 
    gl.glBindVertexArray(vao); 
    gl.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, 0); 
} 

@Override 
public void clean(GL gl) { 
    gl.glDeleteVertexArrays(vao); 
    gl.glDeleteBuffers(vbo); 
    gl.glDeleteBuffers(ebo); 

    ShaderProgram.clearUse(gl); 
    prog.dispose(gl); 
} 

_{Vertexshader einmal ausgeführt}

#version 330 core 

layout (location = 0) in vec3 in_position; 
layout (location = 1) in vec3 in_color; 
layout (location = 2) in vec2 in_texCoord; 

out vec3 color; 
out vec2 texCoord; 

void main() { 
    gl_Position = vec4(in_position, 1.0); 

    color = in_color; 
    texCoord = vec2(in_texCoord.x, in_texCoord.y); 
} 

_{Fragment-Shader}

#version 330 core 

out vec4 frag_colour; 

in vec3 color; 
in vec2 texCoord; 

uniform sampler2D texture; 

void main() { 
    frag_colour = texture(texture, texCoord) * vec4(color, 1.0); 
} 

---

_{Ich wickelte LWJGL3 GL ## statische Klassen in eine einzige Schnittstelle und Implementierung, damit ich eine Reihe von Stateful-Methoden haben kann, die Dinge wie die Identifizierung der Kontext zu tun, die gerendert wird, usw. auch ich habe mein Bestes, um Nicht-Kern-Funktionalität von der Schnittstelle zu entfernen, so dass ich nicht einmal versucht, veraltete Sachen}

Answer 1

Sie aktivieren das Scheitelpunktattribut nur mit dem Index 0, jedoch 3 Mal.

Passen Sie Ihren Code wie folgt aus:

gl.glVertexAttribPointer(0, 3, GL.GL_FLOAT, false, 8 * Float.BYTES, 0); 
gl.glEnableVertexAttribArray(0); 

gl.glVertexAttribPointer(1, 3, GL.GL_FLOAT, false, 8 * Float.BYTES, 3 * Float.BYTES); 
gl.glEnableVertexAttribArray(1); // <------- 

gl.glVertexAttribPointer(2, 2, GL.GL_FLOAT, false, 8 * Float.BYTES, 6 * Float.BYTES); 
gl.glEnableVertexAttribArray(2); // <------ 

Answer 2

Es ist schwer zu sagen, nur durch den Code, aber ein schwarzes Viereck bedeutet, dass diese Zeile in Ihrem Fragment-Shader :

frag_colour = texture(texture, texCoord) * vec4(color, 1.0); 

ergibt 0. Das bedeutet entweder, dass die Textur nicht richtig gelesen/gebunden ist, die Texturkoordinaten ausgeschaltet sind oder die Farbe ein Nullvektor ist. Stellen Sie sicher, dass das Texturbild korrekt geladen ist (Datei existiert, Breite und Höhe usw.) und das richtige Format hat.Was ich in der Regel tun, um die Shader zu debuggen ist, jeden Parameter als eine Farbe zu setzen einen Hinweis zu geben, wenn es um den richtigen Wert hat:

frag_colour = vec4(color, 1.0); //Makes sure the color is right 

oder

frag_colour = texture(texture, texCoord); //Makes sure the texture is loaded and bound 

Und wenn das nicht genug geben Informationen, noch mehr Details:

frag_colour = vec4(color.x, color.x, color.x, 1.0); 

oder

frag_colour = vec4(texCoord.x, texCoord.x, texCoord.x, 1.0);