title: OpenGL 2.0 ES Android Draw Rectangle
body: <p>I'm following Google's tutorial (<a href="http://developer.android.com/training/graphics/opengl/environment.html" rel="nofollow">http://developer.android.com/training/graphics/opengl/environment.html</a>) and i think that i everything correctly done. But i have problem, Triangle and Rectangle is invisible and LogCat doesn't show any error.
  This is my code for rectangle:</p>
  
  <pre><code>package com.example.gameengine;
  
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.nio.FloatBuffer;
  import java.nio.ShortBuffer;
  
  import android.opengl.GLES20;
  
  /**
   * A two-dimensional square for use as a drawn object in OpenGL ES 2.0.
   */
  public class GLObject {
  
      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.
              // Note that the uMVPMatrix factor *must be first* in order
              // for the matrix multiplication product to be correct.
              "  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 ShortBuffer drawListBuffer;
      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;
      static float squareCoords[] = {
              -0.5f,  0.5f, 0.0f,   // top left
              -0.5f, -0.5f, 0.0f,   // bottom left
               0.5f, -0.5f, 0.0f,   // bottom right
               0.5f,  0.5f, 0.0f }; // top right
  
      private final short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices
  
      private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
  
      float color[] = { 0.2f, 0.709803922f, 0.898039216f, 1.0f };
  
      /**
       * Sets up the drawing object data for use in an OpenGL ES context.
       */
      public GLObject() {
          // initialize vertex byte buffer for shape coordinates
          ByteBuffer bb = ByteBuffer.allocateDirect(
          // (# of coordinate values * 4 bytes per float)
                  squareCoords.length * 4);
          bb.order(ByteOrder.nativeOrder());
          vertexBuffer = bb.asFloatBuffer();
          vertexBuffer.put(squareCoords);
          vertexBuffer.position(0);
  
          // initialize byte buffer for the draw list
          ByteBuffer dlb = ByteBuffer.allocateDirect(
                  // (# of coordinate values * 2 bytes per short)
                  drawOrder.length * 2);
          dlb.order(ByteOrder.nativeOrder());
          drawListBuffer = dlb.asShortBuffer();
          drawListBuffer.put(drawOrder);
          drawListBuffer.position(0);
  
          // prepare shaders and OpenGL program
          int vertexShader = GLRenderer.loadShader(
                  GLES20.GL_VERTEX_SHADER,
                  vertexShaderCode);
          int fragmentShader = GLRenderer.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
      }
  
      /**
       * Encapsulates the OpenGL ES instructions for drawing this shape.
       *
       * @param mvpMatrix - The Model View Project matrix in which to draw
       * this shape.
       */
      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 triangle 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 triangle
          GLES20.glUniform4fv(mColorHandle, 1, color, 0);
  
          // get handle to shape's transformation matrix
          mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
          GLRenderer.checkGlError("glGetUniformLocation");
  
          // Apply the projection and view transformation
          GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
          GLRenderer.checkGlError("glUniformMatrix4fv");
  
          // Draw the square
          GLES20.glDrawElements(
                  GLES20.GL_TRIANGLES, drawOrder.length,
                  GLES20.GL_UNSIGNED_SHORT, drawListBuffer);
  
          // Disable vertex array
          GLES20.glDisableVertexAttribArray(mPositionHandle);
      }
  
  }
  </code></pre>
  
  <p>And this is how i draw rectangle:</p>
  
  <pre><code>GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
  
          // Set the camera position (View matrix)
          Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
  
          // Calculate the projection and view transformation
          Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);
  
          // Draw square
          mSquare.draw(mMVPMatrix);
  </code></pre>
  
  <p>GLSurface is correctly implmenent(i can change background color)</p>