Opengl error 1281 when trying to glUseProgram

Question

Any ideas how I could debug this opengl error further? 1281

I'm loading source from files, compiling, linking and then trying to check for errors after glUseProgram

In my object's draw method ..

log.info(gl2.glIsProgram(shaderProgram)); // true
gl2.glUseProgram(shaderProgram);

int error;
while ((error = gl2.glGetError()) != GL2.GL_NO_ERROR) {
    throw new RuntimeException("glUseProgram" + ": glError " + error);
}

Output ..

[13:38:08] INFO (IARectangle.java:99) - true
java.lang.RuntimeException: glUseProgram: glError 1281

This is how I load my shader source, from .glsl files ..

Vector<Integer> shaders = new Vector<Integer>();

try {

    shaders.add(compileSource(
        loadSource("shaders/vertexShader.glsl"),
        loadSource("shaders/fragmentShader.glsl")));

    return shaders;

} catch (Exception e) {
    e.printStackTrace();
    return shaders;
}

public String[] loadSource(String filename){

    StringBuilder sb = new StringBuilder();
    try {

        InputStream is = getClass().getClassLoader().getResourceAsStream(filename);
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
        String line;
        while ((line = br.readLine()) != null) {

            sb.append(line);
            sb.append('\n');
        }
        is.close();

    } catch (Exception e) {
        e.printStackTrace();
    }

    return new String[] { sb.toString() };
}

public final int compileSource(final String[] vertexSource, final String[] fragmentSource) throws Exception {

     vertexShaderProgram;
    int fragmentShaderProgram;
    int shaderProgram;

    // load vertexShader source, compile and verify
    vertexShaderProgram = gl2.glCreateShader(GL2.GL_VERTEX_SHADER);
    gl2.glShaderSource(vertexShaderProgram, 1, vertexSource, null, 0);
    gl2.glCompileShader(vertexShaderProgram);
    verifyCompile(gl2, vertexShaderProgram);

    // load fragmentShader source, compile and verify
    fragmentShaderProgram = gl2.glCreateShader(GL2.GL_FRAGMENT_SHADER);
    gl2.glShaderSource(fragmentShaderProgram, 1, fragmentSource, null, 0);
    gl2.glCompileShader(fragmentShaderProgram);
    verifyCompile(gl2, fragmentShaderProgram);

    shaderProgram = gl2.glCreateProgram();

    gl2.glAttachShader(shaderProgram, vertexShaderProgram);
    gl2.glAttachShader(shaderProgram, fragmentShaderProgram);
    gl2.glLinkProgram(shaderProgram);
    IntBuffer intBuffer = IntBuffer.allocate(1);
    gl2.glGetProgramiv(shaderProgram, GL2.GL_LINK_STATUS, intBuffer);

    if (intBuffer.get(0) != 1){

        String infoLog = null;
        gl2.glGetProgramiv(shaderProgram, GL2.GL_INFO_LOG_LENGTH, intBuffer);
        int size = intBuffer.get(0);
        log.error("Program link error: ");
        if (size > 0) {

            ByteBuffer byteBuffer = ByteBuffer.allocate(size);
            gl2.getGL2().glGetProgramInfoLog(shaderProgram, size, intBuffer, byteBuffer);
            byte[] sizeBytes = new byte[size];
            byteBuffer.get(sizeBytes, 0, size);
            infoLog = new String(sizeBytes);

            log.error("info: " + infoLog);

        } else {
            log.error("Unknown");
        }
        System.exit(1);
        return shaderProgram;

    } else {

        return shaderProgram;
    }
}

Vertex shader source ..

#version 120

uniform mat4 uMVPMatrix;
attribute vec4 vPosition;

void main() {
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    //gl_Position = uMVPMatrix * vPosition;
}

Fragment shader source ..

#version 120

uniform vec4 vColor;

void main() {
    gl_FragColor = vColor;
}

Answer 1

At first glance, I'm not sure why glGetError is returning an error code. But to answer your specific question of 'How can I debug this error further?', I do have a suggestion.

Change your draw code to this:

// Logging errors before the call to glUseProgram
int error;
while ((error = gl2.glGetError()) != GL2.GL_NO_ERROR) {
    log.info(error);
}

log.info(gl2.glIsProgram(shaderProgram)); // true
gl2.glUseProgram(shaderProgram);

int error;
while ((error = gl2.glGetError()) != GL2.GL_NO_ERROR) {
    throw new RuntimeException("glUseProgram" + ": glError " + error);
}

Note that the difference here is we've added a block of code to log errors returned by glGetError before the call to glUseProgram. The reason is because the error is not necessarily originating in your call to glUseProgram. If you see the 1281 error logged using the code above, you can determine that the error is actually originating from an OpenGL call made before the glUseProgram call.

Take a look at the documentation for glGetError:

glGetError returns the value of the error flag. Each detectable error is assigned a numeric code and symbolic name. When an error occurs, the error flag is set to the appropriate error code value. No other errors are recorded until glGetError is called, the error code is returned, and the flag is reset to GL_NO_ERROR.

So, if one of your earlier OpenGL calls (perhaps something in your compileSource function, for example) recorded the 1281 error, and you did not call glGetError anywhere between that point and your call to glUseProgram, you can not reasonably assume that the error is actually originating from the glUseProgram call.

In summary, glGetError does not return the most recent error recorded by an OpenGL call. You need to call glGetError with more granularity in order to pinpoint where the error is originating. This will allow you to troubleshoot the issue you're having and determine exactly which OpenGL call is recording the error.