(LWJGL) Problem mit dem .frag Shader

[Luk10]

Grüße,

Ich schreibe zur Zeit an einem kleinen Testprogramm, dass VBO und Shader verwendet und verwende dazu LWJGL.

Soweit funktioniert alles, jedoch bekommen ich beim Verwenden eines einfachen fragment-Shaders eine schwarze Oberfläche anstatt diese Farbverlaufes:

colorData = new float[] {
							1.0f, 0.0f, 0.0f, 1.0f,
							0.0f, 1.0f, 0.0f, 1.0f,
							0.0f, 0.0f, 1.0f, 1.0f,
};

Hier mein vertex

#version 330

layout (location = 0) in vec4 position;
layout (location = 1) in vec4 color;

smooth out vec4 theColor;

void main()
{
    gl_Position = position;
    theColor = color;
}

und fragment-Shader

#version 330

smooth in vec4 theColor;

out vec4 outputColor;

void main()
{
    outputColor = theColor;
}

Beide werden ohne Fehler compiliert, gelinkt und validiert. Das Program wird ohne Exceptions oder Fehler verwendet, jedoch kommt es zu der unerwünschten schwarzen Färbung wie oben beschrieben. fps sind konstant bei 999.

Ich kann auch bei Bedarf ein KSKB liefern.

 

[Guest2]

Moin,

ja, poste mal ein KSKB. Zumindest mir springt beim Code oben nichts ins Auge.

Viele Grüße,
Fancy

 

[Luk10]

Bisschen viel, aber LWJGL braucht halt ein Set-Up. Einfach mal mit und ohne program testen, man sieht sofort den Unterschied. Shader von oben verwenden.

package de.greenOwlProduction.gopGL;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.opengl.GL20.*;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.FloatBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;


public class GopDisplay {


	public static final int WIDTH = 400;
	public static final int HEIGHT = 320;
	public static final String VERSION = "0.01.1t";

	private boolean running;
	private int vertexHandle, colorHandle, vertShader, fragShader, program;
	private long last, delta, fps;
	private float[] vertexData, colorData;

	private FloatBuffer vertexBuffer, colorBuffer;


	public GopDisplay() {
		running = true;
		vertexHandle = -1;
		colorHandle = -1;
		vertShader = -1;
		fragShader = -1;
		program = -1;
		last = System.nanoTime();
		delta = 0;
		fps = 0;

		vertexBuffer = null;
		vertexData = null;

		initContext();
		initExample();
		run();
	}


	private void initExample() {
		vertexData = new float[] {
									0.0f, 0.5f, 0.0f, 1.0f,
									0.5f, -0.366f, 0.0f, 1.0f,
									-0.5f, -0.366f, 0.0f, 1.0f,
		};
		vertexBuffer = BufferUtils.createFloatBuffer(vertexData.length);
		vertexBuffer.put(vertexData);
		vertexBuffer.flip();

		vertexHandle = glGenBuffers();
		glBindBuffer(GL_ARRAY_BUFFER, vertexHandle);
		glBufferData(GL_ARRAY_BUFFER, vertexBuffer, GL_STATIC_DRAW);
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		colorData = new float[] {
									1.0f, 0.0f, 0.0f, 1.0f,
									0.0f, 1.0f, 0.0f, 1.0f,
									0.0f, 0.0f, 1.0f, 1.0f,
		};
		colorBuffer = BufferUtils.createFloatBuffer(colorData.length);
		colorBuffer.put(colorData);
		colorBuffer.flip();

		colorHandle = glGenBuffers();
		glBindBuffer(GL_ARRAY_BUFFER, colorHandle);
		glBufferData(GL_ARRAY_BUFFER, colorBuffer, GL_STATIC_DRAW);
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		vertShader = glCreateShader(GL_VERTEX_SHADER);
		fragShader = glCreateShader(GL_FRAGMENT_SHADER);
		program = glCreateProgram();

		glShaderSource(vertShader, loadShader("res/shader/shader.vert")); // insert path
		glCompileShader(vertShader);
		glShaderSource(fragShader, loadShader("res/shader/shader.frag")); // insert path
		glCompileShader(fragShader);

		if (glGetShader(vertShader, GL_COMPILE_STATUS) == GL_FALSE) {
			System.err.println("Compilation Error: vertShader");
			final int length = glGetShader(vertShader, GL_INFO_LOG_LENGTH);
			System.err.println(glGetShaderInfoLog(vertShader, length));
			System.exit(1);
		}
		if (glGetShader(fragShader, GL_COMPILE_STATUS) == GL_FALSE) {
			System.err.println("Compilation Error: fragShader");
			final int length = glGetShader(fragShader, GL_INFO_LOG_LENGTH);
			System.err.println(glGetShaderInfoLog(fragShader, length));
			System.exit(1);
		}

		glAttachShader(program, vertShader);
		glAttachShader(program, fragShader);
		glLinkProgram(program);
		glDetachShader(program, vertShader);
		glDetachShader(program, fragShader);

		if (glGetProgram(program, GL_LINK_STATUS) == GL_FALSE) {
			System.err.println("Linking Error: program");
			final int length = glGetProgram(program, GL_INFO_LOG_LENGTH);
			System.err.println(glGetProgramInfoLog(program, length));
			System.exit(1);
		}

		glValidateProgram(program);
	}
	private void initContext() {
		try {
			Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
			Display.setTitle(VERSION);
			Display.create();
		} catch (LWJGLException e) {
			e.printStackTrace();
		}
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		// glOrtho(0, WIDTH, HEIGHT, 0, 1, -1);
		glMatrixMode(GL_MODELVIEW);
	}

	private void computeDelta() {
		delta = System.nanoTime() - last;
		last = System.nanoTime();
		fps = (long) (1e9 / delta);
	}

	private void run() {
		while (running) {
			if (Display.isCloseRequested()) running = false;
			computeDelta();
			draw();
			Display.update();
			// Display.sync(60);
			System.out.println(fps + " fps");
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		glDeleteShader(vertShader);
		glDeleteShader(fragShader);
		glDeleteProgram(program);
		Display.destroy();
	}

	private void draw() {
		glClearColor(1, 1, 1, 1);
		glClear(GL_COLOR_BUFFER_BIT);

		glUseProgram(program);
		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_COLOR_ARRAY);

		glBindBuffer(GL_ARRAY_BUFFER, vertexHandle);
		glVertexPointer(4, GL_FLOAT, 0, 0L);

		glBindBuffer(GL_ARRAY_BUFFER, colorHandle);
		glColorPointer(4, GL_FLOAT, 0, 0L);

		glDrawArrays(GL_TRIANGLES, 0, 3);

		glDisableClientState(GL_COLOR_ARRAY);
		glDisableClientState(GL_VERTEX_ARRAY);

		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glUseProgram(0);
	}

	public static void main(String[] args) {
		new GopDisplay();
	}

	public static StringBuilder loadShader(String path) {
		StringBuilder result = new StringBuilder();
		try {
			BufferedReader reader = new BufferedReader(new FileReader(path));
			String line = null;
			while ((line = reader.readLine()) != null) {
				result.append(line + '\n');
			}
			reader.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

}

 

[Guest2]

Du setzt im Shader zwar die location, bindest die VBOs aber nicht an diese. [c]glVertexPointer
[/c] und [c]glColorPointer[/c] sind auch beide deprecated, heute braucht man eigentlich nur noch [c]glVertexAttribPointer[/c], da kann man dann auch direkt die location mit angeben.

So sollte es gehen:

    private static final int POSITION_LOCATION = 0;
    private static final int COLOR_LOCATION    = 1;


    private void draw() {

        glClearColor(1, 1, 1, 1);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(program);

        glBindBuffer(GL_ARRAY_BUFFER, vertexHandle);
        glEnableVertexAttribArray(POSITION_LOCATION);
        glVertexAttribPointer(POSITION_LOCATION, 4, GL_FLOAT, false, 0, 0);

        glBindBuffer(GL_ARRAY_BUFFER, colorHandle);
        glEnableVertexAttribArray(COLOR_LOCATION);
        glVertexAttribPointer(COLOR_LOCATION, 4, GL_FLOAT, false, 0, 0);

        glDrawArrays(GL_TRIANGLES, 0, 3);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glUseProgram(0);

    }

Viele Grüße,
Fancy

 

[Luk10]

Ah vielen Dank für diese Information. Ich hab mich schon die ganze Zeit gefragt, wie die Indicies für die Shader festgelegt werden. Ist ja ein bisschen anders in C.

Wenn ich

glEnableVertexAttribArray(...);

schreibe sollte ich das dann nicht auch wieder Disablen?

 

[Guest2]

Das ist eine gute Frage! 😉

Wenn man das nicht macht, hat das imho normalerweise keine negativen Konsequenzen. Die einzige Ausnahme ist, wenn man glVertexAttrib() (setzt ein Vertex Attribut für alle Vertices) verwenden möchte.

Wenn Du dich an das OpenGL Core Profile halten möchtest, must Du Dein VBO (oder die VBOs) eh noch in ein VAO verpacken. Und in diesem wird dann auch gespeichert, welche Attribute aktiviert sind. Das reine binden des VAO führt dann schon dazu das alle Zustände korrekt gesetzt werden.

Viele Grüße,
Fancy