OpenGL Android

CS175

Chris Pollett

Nov. 5, 2014

Outline

OpenGL for Android

OpenGL

OpenGL was developed by Silicon Graphics in 1992.
Android implements a subset of OpenGL called OpenGL for Embedded Systems OpenGL ES
There are three main flavors of this: OpenGL ES 1.1 and OpenGL ES 2.x, 3.x (most recent as of Nov, 2014 is 3.1). OpenGL ES 3.x is backward compatible with Open ES 2.x, so we will lump it in with OpenGL ES 2.x
Starting with Android 2.0, Android supports OpenGL ES 2.0
These standards were developed by the Khronos Group which has as members AMD, Apple, Intel, Nvidia, Nokia, Qualcomm, Samsung, and Sony.
The main difference between the flavors is that the graphics pipeline. In 1.x is a pre-shader style pipeline commonly found still in many mainstream Computer Graphics book. The ES 2.x, 3.x standards have a more truncated pipeline which relies on programmer written shaders to achieve many effects.
Shaders are short pieces of C-like code which run on the processing units of a device's GPU. The advantage of shaders is that a typically GPU may have many processing units and the shader code runs in parallel on these units; whereas, old style 1.x OpenGL ES ran in a serial fashion on the device's CPU.
OpenGL ES is also available on iPhone.
Each language has its own binding to OpenGL. Java's binding were defined in JSR239
In addition to Android and iOS, HTML 5 has OpenGL bindings called WebGL.

An OpenGL ES 2 Project

We are going to present a short OpenGL ES 2 project adapted from:
http://www.learnopengles.com/.
Here is a screenshot of what our example will look like:
The triangles in the above spin.
The app itself consists of two classes: an activity and a surface view renderer.

The OpenGL Example's Activity

I created a default Android application.
I then modified the onCreate method to initialize OpenGL and set that it uses our surface renderer rather than the default layout to draw itself.
I also had to override onPause and onResume so that in addition to the activity the renderer properly pauses and resumes itself.

Here is the code:

package com.example.openglexample1;

import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.ConfigurationInfo;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.Menu;
import android.view.MenuItem;


public class MainActivity extends ActionBarActivity {

	/** Hold a reference to our GLSurfaceView */
	private GLSurfaceView mGLSurfaceView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
		mGLSurfaceView = new GLSurfaceView(this);

		// Check if the system supports OpenGL ES 2.0.
		final ActivityManager activityManager = 
                    (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
		final ConfigurationInfo configurationInfo = 
                    activityManager.getDeviceConfigurationInfo();
		final boolean supportsEs2 = configurationInfo.reqGlEsVersion >= 0x20000;

		if (supportsEs2) 
		{
			// Request an OpenGL ES 2.0 compatible context.
			mGLSurfaceView.setEGLContextClientVersion(2);

			// Set the renderer to our demo renderer, defined below.
			mGLSurfaceView.setRenderer(new OpenGLRenderer());
		} 
		else 
		{
			// This is where you could create an OpenGL ES 1.x compatible
			// renderer if you wanted to support both ES 1 and ES 2.
			return;
		}

		setContentView(mGLSurfaceView);
    }

	@Override
	protected void onResume() 
	{
		// The activity must call the GL surface view's onResume() on activity onResume().
		super.onResume();
		mGLSurfaceView.onResume();
	}

	@Override
	protected void onPause() 
	{
		// The activity must call the GL surface view's onPause() on activity onPause().
		super.onPause();
		mGLSurfaceView.onPause();
	}
	
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

Remarks on Example Activity

The main code on the previous slide that is of interest is onCreate.
We use a private field GLSurfaceView mGLSurfaceView as the view for our app.
In general, a GLSurfaceView will be used to render OpenGL ES content regardless of version.

The lines:

final ActivityManager activityManager = 
    (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
final ConfigurationInfo configurationInfo = 
     activityManager.getDeviceConfigurationInfo();
final boolean supportsEs2 = configurationInfo.reqGlEsVersion >= 0x20000;
if (supportsEs2) { ... }

check if our device supports OpenGL ES 2.

If we are publishing to the Android marketplace, we might want to prevent our app from being installed on devices that don't support OpenGL ES 2. To do this we can add the lines:
```
<uses-feature
android:glEsVersion="0x00020000"
android:required="true" />
```
to our manifest.

If so, we get a content and we add our renderer to our GLSurfaceView. The renderer will do the actual drawing:

// Request an OpenGL ES 2.0 compatible context.
mGLSurfaceView.setEGLContextClientVersion(2);

// Set the renderer to our demo renderer, defined below.
mGLSurfaceView.setRenderer(new OpenGLRenderer());

Our Renderer

Below is the complete code of our renderer. Over the next several slides I'll try to explain exactly what it is doing ... I figured it would be helpful though to have the code all in one place.

package com.example.openglexample1;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.os.SystemClock;

/**
 * This class implements our custom renderer. Note that the GL10 
 * parameter passed in is unused for OpenGL ES 2.0
 * renderers -- the static class GLES20 is used instead.
 */
public class OpenGLRenderer implements GLSurfaceView.Renderer {
	/**
	 * Store the model matrix. This matrix is used to move models 
         * from object space (where each model can be thought
	 * of being located at the center of the universe) to world space.
	 */
	private float[] mModelMatrix = new float[16];

	/**
	 * Store the view matrix. This can be thought of as our camera. 
         * This matrix transforms world space to eye space;
	 * it positions things relative to our eye.
	 */
	private float[] mViewMatrix = new float[16];

	/** Store the projection matrix. This is used to project 
         * the scene onto a 2D viewport. 
         */
	private float[] mProjectionMatrix = new float[16];
	
	/** Allocate storage for the final combined matrix. 
         * This will be passed into the shader program.
         */
	private float[] mMVPMatrix = new float[16];
	
	/** Store our model data in a float buffer. */
	private final FloatBuffer mTriangle1Vertices;
	private final FloatBuffer mTriangle2Vertices;
	private final FloatBuffer mTriangle3Vertices;

	/** This will be used to pass in the transformation matrix. */
	private int mMVPMatrixHandle;
	
	/** This will be used to pass in model position information. */
	private int mPositionHandle;
	
	/** This will be used to pass in model color information. */
	private int mColorHandle;

	/** How many bytes per float. */
	private final int mBytesPerFloat = 4;
	
	/** How many elements per vertex. */
	private final int mStrideBytes = 7 * mBytesPerFloat;	
	
	/** Offset of the position data. */
	private final int mPositionOffset = 0;
	
	/** Size of the position data in elements. */
	private final int mPositionDataSize = 3;
	
	/** Offset of the color data. */
	private final int mColorOffset = 3;
	
	/** Size of the color data in elements. */
	private final int mColorDataSize = 4;		
				
	/**
	 * Initialize the model data.
	 */
	public OpenGLRenderer()
	{	
		// Define points for equilateral triangles.
		
		// This triangle is red, green, and blue.
		final float[] triangle1VerticesData = {
				// X, Y, Z, 
				// R, G, B, A
	            -0.5f, -0.25f, 0.0f, 
	            1.0f, 0.0f, 0.0f, 1.0f,
	            
	            0.5f, -0.25f, 0.0f,
	            0.0f, 0.0f, 1.0f, 1.0f,
	            
	            0.0f, 0.559016994f, 0.0f, 
	            0.0f, 1.0f, 0.0f, 1.0f};
		
		// This triangle is yellow, cyan, and magenta.
		final float[] triangle2VerticesData = {
				// X, Y, Z, 
				// R, G, B, A
	            -0.5f, -0.25f, 0.0f, 
	            1.0f, 1.0f, 0.0f, 1.0f,
	            
	            0.5f, -0.25f, 0.0f, 
	            0.0f, 1.0f, 1.0f, 1.0f,
	            
	            0.0f, 0.559016994f, 0.0f, 
	            1.0f, 0.0f, 1.0f, 1.0f};
		
		// This triangle is white, gray, and black.
		final float[] triangle3VerticesData = {
				// X, Y, Z, 
				// R, G, B, A
	            -0.5f, -0.25f, 0.0f, 
	            1.0f, 1.0f, 1.0f, 1.0f,
	            
	            0.5f, -0.25f, 0.0f, 
	            0.5f, 0.5f, 0.5f, 1.0f,
	            
	            0.0f, 0.559016994f, 0.0f, 
	            0.0f, 0.0f, 0.0f, 1.0f};
		
		// Initialize the buffers.
		mTriangle1Vertices = ByteBuffer.allocateDirect(
                    triangle1VerticesData.length * mBytesPerFloat)
                    .order(ByteOrder.nativeOrder()).asFloatBuffer();
		mTriangle2Vertices = ByteBuffer.allocateDirect(
                    triangle2VerticesData.length * mBytesPerFloat)
                    .order(ByteOrder.nativeOrder()).asFloatBuffer();
		mTriangle3Vertices = ByteBuffer.allocateDirect(
                    triangle3VerticesData.length * mBytesPerFloat)
                    .order(ByteOrder.nativeOrder()).asFloatBuffer();
					
		mTriangle1Vertices.put(triangle1VerticesData).position(0);
		mTriangle2Vertices.put(triangle2VerticesData).position(0);
		mTriangle3Vertices.put(triangle3VerticesData).position(0);
	}
	
	@Override
	public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 
	{
		// Set the background clear color to gray.
		GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
	
		// Position the eye behind the origin.
		final float eyeX = 0.0f;
		final float eyeY = 0.0f;
		final float eyeZ = 1.5f;

		// We are looking toward the distance
		final float lookX = 0.0f;
		final float lookY = 0.0f;
		final float lookZ = -5.0f;

		// Set our up vector. This is where our head would be pointing were we holding the camera.
		final float upX = 0.0f;
		final float upY = 1.0f;
		final float upZ = 0.0f;

		/* Set the view matrix. This matrix can be said to represent the camera position.
		 NOTE: In OpenGL 1, a ModelView matrix is used, which is a 
                 combination of a model and view matrix. In OpenGL 2, we can keep track of these 
                 matrices separately if we choose.
                */
		Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

		final String vertexShader =
			"uniform mat4 u_MVPMatrix;      \n" // A constant representing the 
                                                            //combined model/view/projection matrix.
			
		  + "attribute vec4 a_Position;     \n"	// Per-vertex position information we will pass in.
		  + "attribute vec4 a_Color;        \n" // Per-vertex color information we will pass in.			  
		  
		  + "varying vec4 v_Color;          \n"	 // This will be passed into the fragment shader.
		  
		  + "void main()                    \n"	 // The entry point for our vertex shader.
		  + "{                              \n"
		  + "   v_Color = a_Color;          \n"	 // Pass the color through to the fragment shader. 
		  					 // It will be interpolated across the triangle.
		  + "   gl_Position = u_MVPMatrix   \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 			                                            			 
		  + "}                              \n";  // normalized screen coordinates.
		
		final String fragmentShader =
			"precision mediump float;       \n" // Set the default precision to medium. We don't need as high of a 
						            // precision in the fragment shader.				
		  + "varying vec4 v_Color;          \n"	 // This is the color from the vertex shader interpolated across the 
		  					 // triangle per fragment.			  
		  + "void main()                    \n"	 // The entry point for our fragment shader.
		  + "{                              \n"
		  + "   gl_FragColor = v_Color;     \n"	 // Pass the color directly through the pipeline.		  
		  + "}                              \n";												
		
		// Load in the vertex shader.
		int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);

		if (vertexShaderHandle != 0) 
		{
			// Pass in the shader source.
			GLES20.glShaderSource(vertexShaderHandle, vertexShader);

			// Compile the shader.
			GLES20.glCompileShader(vertexShaderHandle);

			// Get the compilation status.
			final int[] compileStatus = new int[1];
			GLES20.glGetShaderiv(vertexShaderHandle, 
                            GLES20.GL_COMPILE_STATUS, compileStatus, 0);

			// If the compilation failed, delete the shader.
			if (compileStatus[0] == 0) 
			{				
				GLES20.glDeleteShader(vertexShaderHandle);
				vertexShaderHandle = 0;
			}
		}

		if (vertexShaderHandle == 0)
		{
			throw new RuntimeException("Error creating vertex shader.");
		}
		
		// Load in the fragment shader shader.
		int fragmentShaderHandle = GLES20.glCreateShader(
                     GLES20.GL_FRAGMENT_SHADER);

		if (fragmentShaderHandle != 0) 
		{
			// Pass in the shader source.
			GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);

			// Compile the shader.
			GLES20.glCompileShader(fragmentShaderHandle);

			// Get the compilation status.
			final int[] compileStatus = new int[1];
			GLES20.glGetShaderiv(fragmentShaderHandle,
                            GLES20.GL_COMPILE_STATUS, compileStatus, 0);

			// If the compilation failed, delete the shader.
			if (compileStatus[0] == 0) 
			{				
				GLES20.glDeleteShader(fragmentShaderHandle);
				fragmentShaderHandle = 0;
			}
		}

		if (fragmentShaderHandle == 0)
		{
			throw new RuntimeException("Error creating fragment shader.");
		}
		
		// Create a program object and store the handle to it.
		int programHandle = GLES20.glCreateProgram();
		
		if (programHandle != 0) 
		{
			// Bind the vertex shader to the program.
			GLES20.glAttachShader(programHandle, vertexShaderHandle);			

			// Bind the fragment shader to the program.
			GLES20.glAttachShader(programHandle, fragmentShaderHandle);
			
			// Bind attributes
			GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
			GLES20.glBindAttribLocation(programHandle, 1, "a_Color");
			
			// Link the two shaders together into a program.
			GLES20.glLinkProgram(programHandle);

			// Get the link status.
			final int[] linkStatus = new int[1];
			GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);

			// If the link failed, delete the program.
			if (linkStatus[0] == 0) 
			{				
				GLES20.glDeleteProgram(programHandle);
				programHandle = 0;
			}
		}
		
		if (programHandle == 0)
		{
			throw new RuntimeException("Error creating program.");
		}
        
        // Set program handles. These will later be used to pass in values to the program.
        mMVPMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");        
        mPositionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
        mColorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");        
        
        // Tell OpenGL to use this program when rendering.
        GLES20.glUseProgram(programHandle);        
	}	
	
	@Override
	public void onSurfaceChanged(GL10 glUnused, int width, int height) 
	{
		// Set the OpenGL viewport to the same size as the surface.
		GLES20.glViewport(0, 0, width, height);

		// Create a new perspective projection matrix. The height will stay the same
		// while the width will vary as per aspect ratio.
		final float ratio = (float) width / height;
		final float left = -ratio;
		final float right = ratio;
		final float bottom = -1.0f;
		final float top = 1.0f;
		final float near = 1.0f;
		final float far = 10.0f;
		
		Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
	}	

	@Override
	public void onDrawFrame(GL10 glUnused) 
	{
		GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);			        
                
        // Do a complete rotation every 10 seconds.
        long time = SystemClock.uptimeMillis() % 10000L;
        float angleInDegrees = (360.0f / 10000.0f) * ((int) time);
        
        // Draw the triangle facing straight on.
        Matrix.setIdentityM(mModelMatrix, 0);
        Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);        
        drawTriangle(mTriangle1Vertices);
        
        // Draw one translated a bit down and rotated to be flat on the ground.
        Matrix.setIdentityM(mModelMatrix, 0);
        Matrix.translateM(mModelMatrix, 0, 0.0f, -1.0f, 0.0f);
        Matrix.rotateM(mModelMatrix, 0, 90.0f, 1.0f, 0.0f, 0.0f);
        Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);        
        drawTriangle(mTriangle2Vertices);
        
        // Draw one translated a bit to the right and rotated to be facing to the left.
        Matrix.setIdentityM(mModelMatrix, 0);
        Matrix.translateM(mModelMatrix, 0, 1.0f, 0.0f, 0.0f);
        Matrix.rotateM(mModelMatrix, 0, 90.0f, 0.0f, 1.0f, 0.0f);
        Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);
        drawTriangle(mTriangle3Vertices);
	}	
	
	/**
	 * Draws a triangle from the given vertex data.
	 * 
	 * @param aTriangleBuffer The buffer containing the vertex data.
	 */
	private void drawTriangle(final FloatBuffer aTriangleBuffer)
	{		
		// Pass in the position information
		aTriangleBuffer.position(mPositionOffset);
        GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false,
        		mStrideBytes, aTriangleBuffer);        
                
        GLES20.glEnableVertexAttribArray(mPositionHandle);        
        
        // Pass in the color information
        aTriangleBuffer.position(mColorOffset);
        GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false,
        		mStrideBytes, aTriangleBuffer);        
        
        GLES20.glEnableVertexAttribArray(mColorHandle);
        
	// This multiplies the view matrix by the model matrix, and stores
        //  the result in the MVP matrix (which currently contains model * view).
        Matrix.multiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
        
        // This multiplies the modelview matrix by the projection matrix,
        // and stores the result in the MVP matrix
        // (which now contains model * view * projection).
        Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);

        GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);                               
	}
}

Renderer Overview

Our renderer consists of the following methods:

Constructor - this sets up float buffers for the three triangles we are going to draw. Each triangle consists of three points. A point consists of seven floats, three for x,y,z position, and four for r, g, b, a color.
onSurfaceCreated(GL10 glUnused, EGLConfig config) -- this is called when our surface view is first created. This sets up the matrices needed to specify our scene. It also compiles a vertex shader, a fragment shader, and links them to create a shader program. Finally, it sets up the slots used to communicate between CPU-land and GPU-land and sets that we are going to use the program we just created.
onSurfaceChanged(GL10 glUnused, int width, int height) -- this is a callback that would be called if our Open GL ES surface view changed in size (in our case it won't happen). It takes the width and height and uses them to create a new projection matrix (the matrix that maps from 3D internal representation down to a 2D thing that is drawn.) After this method is called, onDrawFrame would be called. Our code does not use the provided GL10 object (ES 1.0) which is why we call it glUnused.
public void onDrawFrame(GL10 glUnused) -- This method is actually responsible for drawing triangles. A renderer has a render mode, the default for which is RENDERMODE_CONTINUOUSLY. This is what we are using, so our frame keeps redrawing itself. If we look at the code, it takes the change in time since the app was started and makes an angle from this. For each of the three triangles as 3D points it makes a Model View matrix for a rotation of the triangles about the z-axis about by this angle. Then it calls drawTriangles to draw the triangle.
private void drawTriangle(final FloatBuffer aTriangleBuffer) This is where we draw an individual triangle.

The main methods of interest above are: onSurfaceCreated, drawTriangle. So we will describe them in a little more detail...

onSurfaceCreated -- lookAt matrix

The line:
```
GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
```
clears the background of our surface so that it is gray.
eye, look, and up variables are then set up. These specify a coordinate system for the camera looking at the scene.
From these a 4x4 matrix is built that specifies both a translation to this camera position and a rotation corresponding to where the camera is looking.
Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
Although in computer graphics, we deal with points in 3D. It is useful to work in a 4D space so that both rotations and translations can be done with matrix multiplies rather than have to worry about matrix multiplies and matrix additions.

onSurfaceCreated -- Shaders

This code then sets up our shader program. A shader program consists of two parts: a vertex shader and a fragment shader.
A vertex shader operates on the raw vertices of our triangles applying matrices and colors we have set up for the vertices.
A fragment shader is used to specify how drawing should be done when we are interpolating between the vertices of triangles. I.e., how do we fill in our triangles.

Each kind of shader starts out life as a Java String which we first compile. For example, for our vertex shader we have:

final String vertexShader =
    "uniform mat4 u_MVPMatrix;      \n"
  + "attribute vec4 a_Position;     \n"
  + "attribute vec4 a_Color;        \n"
  + "varying vec4 v_Color;          \n"
  + "void main()                    \n"
  + "{                              \n"
  + "   v_Color = a_Color;          \n"
  + "   gl_Position = u_MVPMatrix   \n"
  + "               * a_Position;   \n"
  + "}                              \n";

Notice this is essentially a C program. The main difference from C is we are not allowed to use recursion, and we have a bunch of new variable keywords, types and operations. For example, in the above, uniform says this variable will come in as a parameter from Java-land and will be the same amongst all vertices considered. attribute says this variable is an attribute of a vertex which we are operating on. mat4 represents a 4x4 matrix of floats, vec4 a vector of 4 floats. * in the above is matrix multiplication.

onSurfaceCreated -- Shaders

To create a shader, we first set up and compile our vertex and fragment shaders. For the vertex shader this looks like:

int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
GLES20.glShaderSource(vertexShaderHandle, vertexShader);
GLES20.glCompileShader(vertexShaderHandle);
// Get the compilation status.
final int[] compileStatus = new int[1];
GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

Once we have done this for our fragment shader as well we make a program out of them, specifying the slots of where data will come into program from Java-land:

int programHandle = GLES20.glCreateProgram();
GLES20.glAttachShader(programHandle, vertexShaderHandle);
GLES20.glAttachShader(programHandle, fragmentShaderHandle);
GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
GLES20.glBindAttribLocation(programHandle, 1, "a_Color");
GLES20.glLinkProgram(programHandle);
mMVPMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");        
mPositionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
mColorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");

To use the program when we draw, we then call:
```
GLES20.glUseProgram(programHandle);
```

drawTriangle

drawTriangle operates on a FloatBuffer with our triangle vertex and color data in it.
Within this buffer, we have a stride, mStrideBytes, that says how many floats are used to represent one point (7) a position offset (0) to the first float that contains position data and another mColorOffset to the color floats within a particular group of seven points.

To pass the position data over to the a_Position attribute in GPU land and say we want to use it, we do:

aTriangleBuffer.position(mPositionOffset);
GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false,
   mStrideBytes, aTriangleBuffer);
GLES20.glEnableVertexAttribArray(mPositionHandle);

Similar code is used to pass the color data.
A triangle starts off in model coordinates, which is mapped to world coordinates with a model matrix, this in turn is mapped into eye coordinates using a view matrix. Finally, a projection matrix is used to project from 3D down to 2D. We multiply these three matrices first, then send their product over to our shader and draw with the following code:
```
Matrix.multiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0); 
Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
```