OpenGL 2.0 ES 1281 Error on glEnableVertexAttribArray

Question

I am using the code from https://github.com/d3kod/Texample2 to render text in OpenGL 2.0. An explanation of that project can be found at http://primalpond.wordpress.com/2013/02/26/rendering-text-in-opengl-2-0-es-on-android/

The code works great on my Samsung Galaxy S3 running android 4.1.2. However, it doesn't work on my Droid X running android 2.3.4, and someone else has had this problem on an android 4.0.4 Onepad 940 tablet (see http://primalpond.wordpress.com/2013/02/26/rendering-text-in-opengl-2-0-es-on-android/#comment-89).

I get a 1281 error on the line: GLES20.glEnableVertexAttribArray(mColorHandle)

I’ve determined that this is because the GL_MAX_VERTEX_ATTRIBS on my Droid X is only 8, and mColorHandle is set to 26. When I run my app on my Samsung GS3, GL_MAX_VERTEX_ATTRIBS is 16, but mColorHandle is set to 0.

So since 26>8, the 1281 error gets thrown. I don’t understand why the Droid gets a handle value of 26 and the GS3 gets 0.

The mProgram program is set in this line in an object constructor:

mColorHandle = GLES20.glGetUniformLocation(mProgram.getHandle(), "u_Color");

This is where the line is that creates the error:

void initDraw(float red, float green, float blue, float alpha) {
GLES20.glUseProgram(mProgram.getHandle()); // specify the program to use

// set color TODO: only alpha component works, text is always black #BUG
float[] color = {red, green, blue, alpha}; 
GLES20.glUniform4fv(mColorHandle, 1, color , 0); 
GLES20.glEnableVertexAttribArray(mColorHandle);

GLES20.glActiveTexture(GLES20.GL_TEXTURE0);  // Set the active texture unit to texture unit 0

GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId); // Bind the texture to this unit

// Tell the texture uniform sampler to use this texture in the shader by binding to texture unit 0
GLES20.glUniform1i(mTextureUniformHandle, 0); 
//Log.i("error", "glerror3: " + GLES20.glGetError());
}

Edit

This is the class that sets up the program:

public class BatchTextProgram extends Program {

private static final AttribVariable[] programVariables = {
    AttribVariable.A_Position, AttribVariable.A_TexCoordinate, AttribVariable.A_MVPMatrixIndex
};

private static final String vertexShaderCode =
        "uniform mat4 u_MVPMatrix[24];      \n"     // An array representing the combined 
                                                    // model/view/projection matrices for each sprite

      + "attribute float a_MVPMatrixIndex; \n"  // The index of the MVPMatrix of the particular sprite
      + "attribute vec4 a_Position;     \n"     // Per-vertex position information we will pass in.
      + "attribute vec2 a_TexCoordinate;\n"     // Per-vertex texture coordinate information we will pass in
      + "varying vec2 v_TexCoordinate;  \n"   // This will be passed into the fragment shader.
      + "void main()                    \n"     // The entry point for our vertex shader.
      + "{                              \n"
      + "   int mvpMatrixIndex = int(a_MVPMatrixIndex); \n"
      + "   v_TexCoordinate = a_TexCoordinate; \n"
      + "   gl_Position = u_MVPMatrix[mvpMatrixIndex]   \n"     // gl_Position is a special variable used to store the final position.
      + "               * a_Position;   \n"     // Multiply the vertex by the matrix to get the final point in
                                                // normalized screen coordinates.
      + "}                              \n";    


private static final String fragmentShaderCode =
        "uniform sampler2D u_Texture;       \n"    // The input texture.
        +   "precision mediump float;       \n"     // Set the default precision to medium. We don't need as high of a
        // precision in the fragment shader.
        + "uniform vec4 u_Color;          \n"
        + "varying vec2 v_TexCoordinate;  \n" // Interpolated texture coordinate per fragment.

        + "void main()                    \n"     // The entry point for our fragment shader.
        + "{                              \n"
        + "   gl_FragColor = texture2D(u_Texture, v_TexCoordinate).w * u_Color;\n" // texture is grayscale so take only grayscale value from  
                                                                                   // it when computing color output (otherwise font is always black)
        + "}                             \n";

@Override
public void init() {
    super.init(vertexShaderCode, fragmentShaderCode, programVariables);
}

}

Answer 1

Your logic is broken. If u_Color is a uniform, it can't be a vertex attribute. Fix that.