title: GLES20.glGetAttribLocation() returns -1
body: <p>I am having trouble getting my Android OpenGL ES 2.0 application working.  I have a "Triangle"  class very similar to several tutorials out there.  In the "draw" function, mPositionHande is -1 after the following line of code:</p>
  
  <pre><code>mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
  </code></pre>
  
  <p>Below is the entire triangle class which has shader code etc.  Any ideas what might cause this?  Sorry, I am new to OpenGL programming, so maybe this is a dumb question.</p>
  
  <pre><code>public class Triangle {
  
  private final String vertexShaderCode =
      // This matrix member variable provides a hook to manipulate
      // the coordinates of the objects that use this vertex shader
      "uniform mat4 uMVPMatrix;" +
  
      "attribute vec4 vPosition;" +
      "void main() {" +
      // the matrix must be included as a modifier of gl_Position
      "  gl_Position = uMVPMatrix * vPosition;" +
      "}";
  
  private final String fragmentShaderCode =
      "precision mediump float;" +
      "uniform vec4 vColor;" +
      "void main() {" +
      "  gl_FragColor = vColor;" +
      "}";
  
  private final FloatBuffer vertexBuffer;
  private final int mProgram;
  private int mPositionHandle;
  private int mColorHandle;
  private int mMVPMatrixHandle;
  
  // number of coordinates per vertex in this array
  static final int COORDS_PER_VERTEX = 3;
  public float triangleCoords[];
  
  private final int vertexCount = 3; //triangleCoords.length / COORDS_PER_VERTEX;
  private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
  
  // Set color with red, green, blue and alpha (opacity) values
  float color[] = { 0.5f, 1.0f, 0.5f, 1.0f };
  float edgeColor[] = { 0.0f, 0.0f, 0.0f, 1.0f };
  
  public Triangle(float[] vertices) {
      this.triangleCoords = vertices;
  
      // initialize vertex byte buffer for shape coordinates
      ByteBuffer bb = ByteBuffer.allocateDirect(
              // (number of coordinate values * 4 bytes per float)
              triangleCoords.length * 4);
      // use the device hardware's native byte order
      bb.order(ByteOrder.nativeOrder());
  
      // create a floating point buffer from the ByteBuffer
      vertexBuffer = bb.asFloatBuffer();
      // add the coordinates to the FloatBuffer
      vertexBuffer.put(triangleCoords);
      // set the buffer to read the first coordinate
      vertexBuffer.position(0);
  
      // prepare shaders and OpenGL program
      int vertexShader = MyRenderer.loadShader(GLES20.GL_VERTEX_SHADER,
                                                 vertexShaderCode);
      int fragmentShader = MyRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,
                                                   fragmentShaderCode);
  
      mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
      GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
      GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
      GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables
  
  }
  
  public void draw(float[] mvpMatrix) {
      // Add program to OpenGL environment
      GLES20.glUseProgram(mProgram);
  
      // get handle to vertex shader's vPosition member
      mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
  
      // Enable a handle to the facet vertices
      GLES20.glEnableVertexAttribArray(mPositionHandle);
  
      // Prepare the triangle coordinate data
      GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX,
                                   GLES20.GL_FLOAT, false,
                                   vertexStride, vertexBuffer);
  
      // get handle to fragment shader's vColor member
      mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
  
      // Set color for drawing the facet
      GLES20.glUniform4fv(mColorHandle, 1, color, 0);
  
      // get handle to shape's transformation matrix
      mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
      MyRenderer.checkGlError("glGetUniformLocation");
  
      // Apply the projection and view transformation
      GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
      MyRenderer.checkGlError("glUniformMatrix4fv");
  
      // Draw the facet
      GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
      //If edge mode
      //GLES20.glUniform4fv(mColorHandle, 1, edgeColor, 0);
      //GLES20.glLineWidth(2.0f);
      //GLES20.glDrawArrays(GLES20.GL_LINE_STRIP, 0, vertexCount);
  
      // Disable vertex array
      GLES20.glDisableVertexAttribArray(mPositionHandle);
  }
  </code></pre>
  
  <p>}</p>