reading from vertex buffer does not change the display content

Newbie & Debugging Questions
#1

Hello,

i am new to java game development. I want to rotate a triangle which is explained in the OpenGL Superbible tutorial.
The steps i did are as follows:

  1. tell opengl to give me an id for the buffer
  2. bind the buffer to the opengl context
  3. set the buffer size to number of vertices * 4 (X,Y,Z,opaque)

in my rendering function i am doing the following:

  1. bind the buffer
  2. update the buffer content with new one
  3. retrieve the attribute for changing his value
  4. tell the shader variables where to find the data

my Main class (or test class) is the following:


package javaopengl;

import java.nio.FloatBuffer;
import java.nio.file.Files;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;
import org.lwjgl.util.mapped.MappedObject;

public class Main extends SB6 {
	
	private
		int renderingProgram;
		int vertexArrayObject;
		int buffer;
		int numVertices = 3;
	
	@Override
	public void render(double currentTime) {	
		
		// Set background color to red
		float[] color = {1.0f, 0.0f, 0.0f, 1.0f};
		int len = color.length;
		FloatBuffer fb = BufferUtils.createFloatBuffer(len*4);
		fb.put(color);
		GL30.glClearBuffer(GL11.GL_COLOR, 0, fb);
		
		// Get new offset position
		FloatBuffer cBuffer = BufferUtils.createFloatBuffer(12);
		cBuffer.put((float)(Math.sin(currentTime) * 0.5 + 0.5)).
						put(((float)(Math.cos(currentTime) * 0.5 + 0.5))).
						put(0.0f).put(1.0f);
		cBuffer.flip();
		
		// Update the data in the buffer
		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, buffer);
		GL15.glBufferSubData(GL15.GL_ARRAY_BUFFER, 0, cBuffer);
		
		// Tell the vertex-shader where to find the data
		int id = GL20.glGetAttribLocation(renderingProgram, "offset");
		GL20.glVertexAttribPointer(id, 3, GL11.GL_FLOAT, false, 0, 0);
		
		// Use the program object we created earlier for rendering
		GL20.glUseProgram(renderingProgram);
		
		GL20.glEnableVertexAttribArray(id);
	}
	
	@Override
	public void startup() {
		renderingProgram = compileShaders();
		
		buffer = GL15.glGenBuffers();
		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, buffer);
		
		// Determine the size of the buffer
		GL15.glBufferData(GL15.GL_ARRAY_BUFFER, numVertices*4, GL15.GL_STATIC_DRAW);
	}	
	
	@Override
	public void shutdown() {
		GL30.glDeleteVertexArrays(vertexArrayObject);
		GL20.glDeleteProgram(shaderProgram);
	}
	
	public static void main(String[] argv) {
		new Main().run();
	}
}

my SB6 class where i am deriving from:


package javaopengl;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.ContextAttribs;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.PixelFormat;


public class SB6 {
	
	private
		int vertexShader;
		int fragmentShader;
		int shaderProgram;
		StringBuilder vertexShaderSource;
		StringBuilder fragmentShaderSource;
	
	public void run() {
		// init opengl
		setupOpenGLVersion();
		startup();
				
		String strTime = new SimpleDateFormat("HHmmss").format(Calendar.getInstance().getTime());
		double dTime = Double.parseDouble(strTime);
		
		while(!Display.isCloseRequested()) {			
			dTime += 0.01;
			//System.err.println(dTime);
			render(dTime);
			Display.update();
			Display.sync(30);
		}
		shutdown();
		Display.destroy();
		System.exit(0);
	}
	
	public int compileShaders() {
		shaderProgram = GL20.glCreateProgram();
		vertexShader = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
		fragmentShader = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
		vertexShaderSource = new StringBuilder();		
		fragmentShaderSource = new StringBuilder();	
		
		try {
			BufferedReader reader = new BufferedReader(new FileReader("src/javaopengl/shader.vert"));
			String line;
			
			while((line = reader.readLine()) != null) {
				vertexShaderSource.append(line).append('\n');
			}
			reader.close();
			
		} catch(IOException e) {
			System.err.println("Vertex shader wasn't loaded properly");
			Display.destroy();
			System.exit(1);
		}
		//System.out.println(vertexShaderSource);
		
		try {
			BufferedReader reader = new BufferedReader(new FileReader("src/javaopengl/shader.frag"));
			String line;
			
			while((line = reader.readLine()) != null) {
				fragmentShaderSource.append(line).append('\n');
			}
			reader.close();
			
		} catch(IOException e) {
			System.err.println("Vertex shader wasn't loaded properly");
			Display.destroy();
			System.exit(1);
		}
		
		GL20.glShaderSource(vertexShader, vertexShaderSource);
		GL20.glCompileShader(vertexShader);
		if(GL20.glGetShader(vertexShader, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) {
			System.err.println("Vertex shader was not compiled successful\n");
			System.err.println(GL20.glGetShaderInfoLog(vertexShader, GL20.GL_INFO_LOG_LENGTH));
		}
		GL20.glShaderSource(fragmentShader, fragmentShaderSource);
		GL20.glCompileShader(fragmentShader);
		if(GL20.glGetShader(fragmentShader, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) {
			System.err.println("Frgament shader was not compiled successful\n");
			System.err.println(GL20.glGetShaderInfoLog(fragmentShader, GL20.GL_INFO_LOG_LENGTH));
		}
		shaderProgram = GL20.glCreateProgram();
		GL20.glAttachShader(shaderProgram, vertexShader);
		GL20.glAttachShader(shaderProgram, fragmentShader);
		GL20.glLinkProgram(shaderProgram);
		
		GL20.glDeleteShader(vertexShader);
		GL20.glDeleteShader(fragmentShader);
		
		return shaderProgram;
	}
	
	public void setupOpenGLVersion() {
		PixelFormat pixelFormat = new PixelFormat();
			ContextAttribs contextAttribs = new ContextAttribs(3, 2)
			.withForwardCompatible(true)
			.withProfileCore(true);
		
		try {			
			Display.setDisplayMode(new DisplayMode(800, 600));
			Display.setTitle("SuperBible6 Example");
			Display.create(pixelFormat, contextAttribs);
			
		}	catch(LWJGLException e) {
				System.err.println("Display was not initialized correctly");
				System.exit(1);
		}
		System.err.println("OpenGL-Version: "+GL11.glGetString(GL11.GL_VERSION));
	}
	
	// Memberfunctions for overriding
	protected void startup() {}
	
	protected void render(double currentTime) {}
	
	protected void shutdown() {}
}

and the two shaders are:

Vertex-Shader


#version 410 core

layout(location = 0) in vec4 offset;

void main() {
    const vec4 vertices[3] = vec4[3](vec4(0.25, -0.25, 0.5, 1.0),
                                    vec4(-0.25, -0.25, 0.5, 1.0),
                                    vec4(0.25, 0.25, 0.5, 1.0));

    gl_Position = vertices[gl_VertexID] + offset;
}



Fragment-Shader
#version 410 core
out vec4 color;

void main() {
    color = vec4(0.0, 0.8, 1.0, 1.0);
}

Can someone tell me why this is not working? The output should be a triangle
in a specific color which rotates onto the display, but i still got a black screen.

Thanx in advance for any helps