Java – my shaderprogram doesn’t work

My main language is French. I will try my best

I try to understand shaders, but I can't find out why my shaders don't work I use VAO to draw 2 vbos One for vertices and one for indexes My object renders well, but my shader doesn't seem to have any effect

My SVN project solar eclipse; http://sourceforge.net/projects/mad-game-engine

My VAO settings; VAO – VBO 0 vertex – VBO 1 exponent

My shaderprogram;

package fr.mad.engine.shader;

import java.io.BufferedReader;
import java.io.FileReader;

import com.jogamp.opengl.GL;
import com.jogamp.opengl.GL2;
import com.jogamp.opengl.GL2ES2;
import com.jogamp.opengl.GL4;

import fr.mad.engine.LOG;

public abstract class ShaderProgram {
    private int programID;
    private int vertexShaderID;
    private int fragmentShaerID;
    private LOG log;

    public ShaderProgram(String vertexFile,String fragmentFile,LOG log,GL2 gl) {
        this.log = new LOG(log,"shader");
        vertexShaderID = loadShader(vertexFile,GL2ES2.GL_VERTEX_SHADER,gl.getGL2());
        fragmentShaerID = loadShader(fragmentFile,GL2ES2.GL_FRAGMENT_SHADER,gl.getGL2());
        programID = gl.glCreateProgram();
        gl.glAttachShader(programID,vertexShaderID);
        gl.glAttachShader(programID,fragmentShaerID);
        bindAttributes(gl);
        gl.glLinkProgram(programID);
        gl.glValidateProgram(programID);
        checkProgram(gl,programID);
    }

    public void start(GL2 gl) {
        gl.glUseProgram(programID);
    }

    public void stop(GL2 gl) {
        gl.glUseProgram(0);
    }

    public void clenUp(GL2 gl) {
        stop(gl);
        gl.glDetachShader(programID,vertexShaderID);
        gl.glDetachShader(programID,fragmentShaerID);
        gl.glDeleteShader(vertexShaderID);
        gl.glDeleteShader(this.fragmentShaerID);
        gl.glDeleteProgram(programID);
    }

    protected abstract void bindAttributes(GL2 gl);

    protected void bindAttribute(GL2 gl,int i,String t) {
        gl.glBindAttribLocation(programID,i,t);
    }

    private int loadShader(String file,int type,GL2 gl) {
        log.log("Loading " + (GL2ES2.GL_VERTEX_SHADER == type ? "Vertex" : "Fragment") + " Shader");
        StringBuilder shaderSource = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line;
            while ((line = reader.readLine()) != null) {
                shaderSource.append(line).append("\n");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        int shaderID = gl.glCreateShader(type);
        gl.glShaderSource(shaderID,1,new String[] { shaderSource.toString() },new int[] { shaderSource.toString().length() },0);
        gl.glCompileShader(shaderID);

        checkShader(gl,shaderID);

        log.log("");

        return shaderID;
    }

    private void checkProgram(GL2 gl,int handle) {

        int[] buffer = new int[1];

        gl.glGetObjectParameterivARB(handle,GL2.GL_OBJECT_LINK_STATUS_ARB,buffer,0);
        if (buffer[0] == GL.GL_FALSE) // 1 or 0
            warning("error linking program ");

        gl.glValidateProgramARB(handle);
        gl.glGetObjectParameterivARB(handle,GL2.GL_OBJECT_VALIDATE_STATUS_ARB,0);
        if (buffer[0] == GL.GL_FALSE)
            warning("program not validate");

        gl.glGetObjectParameterivARB(handle,GL2.GL_OBJECT_INFO_LOG_LENGTH_ARB,0);
        byte[] log = new byte[buffer[0]];
        gl.glGetInfoLogARB(handle,buffer[0],log,0);

        if (log[0] != 0)
            warning("linker info log:\n" + new String(log));
    }

    private void checkShader(GL2 gl,int handle) {

        int[] buffer = new int[1];
        gl.glGetObjectParameterivARB(handle,GL2.GL_OBJECT_COMPILE_STATUS_ARB,0);
        if (buffer[0] == GL.GL_FALSE) {
            warning("error compiling shader");
        }

        gl.glGetObjectParameterivARB(handle,0);

        if (log[0] != 0)
            warning("compiler info log:\n" + new String(log,log.length - 1));
    }

    private void warning(String string) {
        log.log(string);
    }

}

Vertex shader;

#version 400 core

in vec3 position;

out vec3 colour;

void main(void){

    gl_Position = vec4(position.xyz,1.0);
    colour = sin(vec3(0,0));
}

fragment;

#version 400 core

in vec3 colour;

out vec4 out_Color;

void main(void){
    out_Color = vec4(colour,1.0);
    gl_FragColor = vec4(colour,1.0);
}

My painting method;

shader.start(gl);
gl.glBindVertexArray(vaoid);
gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,vbovertid);
gl.glEnabLevertexAttribArray(0);
gl.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER,vboindexid);
gl.glEnabLevertexAttribArray(1);
gl.glColor3f(1f,0);
gl.glDrawElements(GL.GL_TRIANGLES,this.indices.length,GL.GL_UNSIGNED_INT,0);
gl.glEnabLevertexAttribArray(1);
gl.glEnabLevertexAttribArray(0);
gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,0);
gl.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER,0);
gl.glBindVertexArray(0);
shader.stop(gl);

Use theses method in shader program;

private void checkProgram(GL2 gl,int handle) {

        int[] buffer = new int[1];

        gl.glGetProgramiv(handle,GL2ES2.GL_LINK_STATUS,0);
        if (buffer[0] == GL.GL_FALSE) // 1 or 0
            warning("error linking program ");

        gl.glValidateProgram(handle);
        gl.glGetProgramiv(handle,GL2.GL_VALIDATE_STATUS,0);
        if (buffer[0] == GL.GL_FALSE)
            warning("program not validate");

        gl.glGetProgramiv(handle,GL2.GL_INFO_LOG_LENGTH,0);
        byte[] log = new byte[buffer[0]];
        gl.glGetProgramInfoLog(handle,int handle) {

        int[] buffer = new int[1];
        gl.glGetProgramiv(handle,GL2.GL_COMPILE_STATUS,0);
        if (buffer[0] == GL.GL_FALSE) {
            warning("error compiling shader");
        }

        gl.glGetProgramiv(handle,0);
        byte[] log = new byte[buffer[0]];
        if(log.length>0)
        gl.glGetShaderInfoLog(handle,0);

        if(log.length>0)
        if (log[0] != 0)
            warning("compiler info log:\n" + new String(log,log.length - 1));
    }

I got this log;

Loading Vertex Shader
error compiling shader

Loading Fragment Shader
error compiling shader

error linking program 
program not validate

Solution

As I wrote before your blog was not compiled / linked by glsl, you have screwed up somewhere When I put shaders into my engine, here is the log of NVIDIA environment:

[Vertex]
OK

[Fragment]
OK
0(9) : warning C7533: global variable gl_FragColor is deprecated after version 120

[Program]
Linker error
Fragment info
-------------
0(9) : warning C7533: global variable gl_FragColor is deprecated after version 120
error:  user-defined fragment shader outputs may not be used with gl_FragColor or gl_FragData

Therefore, change the clip shader to:

#version 400 core

in vec3 colour;

out vec4 out_Color;

void main(void){
    out_Color = vec4(colour,1.0);
}

By deleting GL_ Fragcolor = vec4 (color, 1.0); Because you have set the output color You can do it only once... If you still need old style variables, use the compatibility profile instead of the core

Check: glgetshaderinfo log

I bet you're calling a different glgetshaderinfo log provided by any GL based library you link to the program That's why you have these strange messages instead of compiling / linking logs Try using the original GL, which returns logs directly from the gfx driver