Sample code for OpenGL Android training class

( Original Id: Ib1650025a3c4b018c60d70ede3f25113660f68d8 )

Change-Id: I1d760b75d1f2bfe1ec90c71471867577bd146241

20 files changed, 1221 insertions, 0 deletions

diff --git a/samples/OpenGL/HelloOpenGLES10/.gitignore b/samples/OpenGL/HelloOpenGLES10/.gitignore
new file mode 100644
index 000000000..ad7a3ead5
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/.gitignore
@@ -0,0 +1,9 @@
+# Files ignored for git source control
+#
+# Add this file to source control so the following files
+# are not tracked and added to git:
+.project
+.classpath
+project.properties
+bin/
+gen/
diff --git a/samples/OpenGL/HelloOpenGLES10/AndroidManifest.xml b/samples/OpenGL/HelloOpenGLES10/AndroidManifest.xml
new file mode 100644
index 000000000..64097dadc
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/AndroidManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.android.opengl"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk
+            android:minSdkVersion="4"
+            android:targetSdkVersion="17" />
+
+    <!-- Tell the system this app requires OpenGL ES 1.0 or higher-->
+    <uses-feature android:glEsVersion="0x00010000" />
+
+    <application
+            android:icon="@drawable/ic_launcher"
+            android:label="@string/app_name"
+            android:allowBackup="true" >
+        <activity
+                android:name="com.example.android.opengl.OpenGLES10Activity"
+                android:label="@string/app_name" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES10/res/drawable/ic_launcher.png b/samples/OpenGL/HelloOpenGLES10/res/drawable/ic_launcher.png
new file mode 100644
index 000000000..359047dfa
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/res/drawable/ic_launcher.png
diff --git a/samples/OpenGL/HelloOpenGLES10/res/layout/main.xml b/samples/OpenGL/HelloOpenGLES10/res/layout/main.xml
new file mode 100644
index 000000000..7c7aee80d
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/res/layout/main.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<LinearLayout
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:orientation="vertical" >
+
+    <TextView
+            android:layout_width="fill_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/hello" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES10/res/values/strings.xml b/samples/OpenGL/HelloOpenGLES10/res/values/strings.xml
new file mode 100644
index 000000000..e4488894f
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/res/values/strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+    <string name="hello">Hello, OpenGL ES 1.0!</string>
+    <string name="app_name">Hello OpenGL ES 1.0</string>
+</resources>
diff --git a/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLRenderer.java b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLRenderer.java
new file mode 100644
index 000000000..96efb3858
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLRenderer.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+import android.opengl.GLSurfaceView;
+import android.opengl.GLU;
+
+/**
+ * Provides drawing instructions for a GLSurfaceView object. This class
+ * must override the OpenGL ES drawing lifecycle methods:
+ * <ul>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceCreated}</li>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onDrawFrame}</li>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceChanged}</li>
+ * </ul>
+ */
+public class MyGLRenderer implements GLSurfaceView.Renderer {
+
+    private Triangle mTriangle;
+    private Square mSquare;
+    private float mAngle;
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        // Set the background frame color
+        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+        mTriangle = new Triangle();
+        mSquare = new Square();
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+
+        // Draw background color
+        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
+
+        // Set GL_MODELVIEW transformation mode
+        gl.glMatrixMode(GL10.GL_MODELVIEW);
+        gl.glLoadIdentity();   // reset the matrix to its default state
+
+        // When using GL_MODELVIEW, you must set the view point
+        GLU.gluLookAt(gl, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
+
+        // Draw square
+        mSquare.draw(gl);
+
+        // Create a rotation for the triangle
+
+        // Use the following code to generate constant rotation.
+        // Leave this code out when using TouchEvents.
+        // long time = SystemClock.uptimeMillis() % 4000L;
+        // float angle = 0.090f * ((int) time);
+
+        gl.glRotatef(mAngle, 0.0f, 0.0f, 1.0f);
+
+        // Draw triangle
+        mTriangle.draw(gl);
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        // Adjust the viewport based on geometry changes
+        // such as screen rotations
+        gl.glViewport(0, 0, width, height);
+
+        // make adjustments for screen ratio
+        float ratio = (float) width / height;
+        gl.glMatrixMode(GL10.GL_PROJECTION);        // set matrix to projection mode
+        gl.glLoadIdentity();                        // reset the matrix to its default state
+        gl.glFrustumf(-ratio, ratio, -1, 1, 3, 7);  // apply the projection matrix
+    }
+
+    /**
+     * Returns the rotation angle of the triangle shape (mTriangle).
+     *
+     * @return - A float representing the rotation angle.
+     */
+    public float getAngle() {
+        return mAngle;
+    }
+
+    /**
+     * Sets the rotation angle of the triangle shape (mTriangle).
+     */
+    public void setAngle(float angle) {
+        mAngle = angle;
+    }
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLSurfaceView.java b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLSurfaceView.java
new file mode 100644
index 000000000..e9b2c8c93
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/MyGLSurfaceView.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.view.MotionEvent;
+
+/**
+ * A view container where OpenGL ES graphics can be drawn on screen.
+ * This view can also be used to capture touch events, such as a user
+ * interacting with drawn objects.
+ */
+public class MyGLSurfaceView extends GLSurfaceView {
+
+    private final MyGLRenderer mRenderer;
+
+    public MyGLSurfaceView(Context context) {
+        super(context);
+
+        // Set the Renderer for drawing on the GLSurfaceView
+        mRenderer = new MyGLRenderer();
+        setRenderer(mRenderer);
+
+        // Render the view only when there is a change in the drawing data
+        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
+    }
+
+    private final float TOUCH_SCALE_FACTOR = 180.0f / 320;
+    private float mPreviousX;
+    private float mPreviousY;
+
+    @Override
+    public boolean onTouchEvent(MotionEvent e) {
+        // MotionEvent reports input details from the touch screen
+        // and other input controls. In this case, we are only
+        // interested in events where the touch position changed.
+
+        float x = e.getX();
+        float y = e.getY();
+
+        switch (e.getAction()) {
+            case MotionEvent.ACTION_MOVE:
+
+                float dx = x - mPreviousX;
+                float dy = y - mPreviousY;
+
+                // reverse direction of rotation above the mid-line
+                if (y > getHeight() / 2) {
+                    dx = dx * -1 ;
+                }
+
+                // reverse direction of rotation to left of the mid-line
+                if (x < getWidth() / 2) {
+                    dy = dy * -1 ;
+                }
+
+                mRenderer.setAngle(
+                        mRenderer.getAngle() +
+                        ((dx + dy) * TOUCH_SCALE_FACTOR));  // = 180.0f / 320
+                requestRender();
+        }
+
+        mPreviousX = x;
+        mPreviousY = y;
+        return true;
+    }
+
+}
diff --git a/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/OpenGLES10Activity.java b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/OpenGLES10Activity.java
new file mode 100644
index 000000000..44abd20ff
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/OpenGLES10Activity.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import android.app.Activity;
+import android.opengl.GLSurfaceView;
+import android.os.Bundle;
+
+public class OpenGLES10Activity extends Activity {
+
+    private GLSurfaceView mGLView;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Create a GLSurfaceView instance and set it
+        // as the ContentView for this Activity.
+        mGLView = new MyGLSurfaceView(this);
+        setContentView(mGLView);
+    }
+
+    @Override
+    protected void onPause() {
+        // The following call pauses the rendering thread.
+        // If your OpenGL application is memory intensive,
+        // you should consider de-allocating objects that
+        // consume significant memory here.
+        super.onPause();
+        mGLView.onPause();
+    }
+
+    @Override
+    protected void onResume() {
+        // The following call resumes a paused rendering thread.
+        // If you de-allocated graphic objects for onPause()
+        // this is a good place to re-allocate them.
+        super.onResume();
+        mGLView.onResume();
+    }
+
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Square.java b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Square.java
new file mode 100644
index 000000000..85f3a4a2a
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Square.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * A two-dimensional square for use as a drawn object in OpenGL ES 1.0/1.1.
+ */
+public class Square {
+
+    private final FloatBuffer vertexBuffer;
+    private final ShortBuffer drawListBuffer;
+
+    // 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
+
+    float color[] = { 0.2f, 0.709803922f, 0.898039216f, 1.0f };
+
+    /**
+     * Sets up the drawing object data for use in an OpenGL ES context.
+     */
+    public Square() {
+        // 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);
+    }
+
+    /**
+     * Encapsulates the OpenGL ES instructions for drawing this shape.
+     *
+     * @param gl - The OpenGL ES context in which to draw this shape.
+     */
+    public void draw(GL10 gl) {
+        // Since this shape uses vertex arrays, enable them
+        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+
+        // draw the shape
+        gl.glColor4f(       // set color
+                color[0], color[1],
+                color[2], color[3]);
+        gl.glVertexPointer( // point to vertex data:
+                COORDS_PER_VERTEX,
+                GL10.GL_FLOAT, 0, vertexBuffer);
+        gl.glDrawElements(  // draw shape:
+                GL10.GL_TRIANGLES,
+                drawOrder.length, GL10.GL_UNSIGNED_SHORT,
+                drawListBuffer);
+
+        // Disable vertex array drawing to avoid
+        // conflicts with shapes that don't use it
+        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    }
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Triangle.java b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Triangle.java
new file mode 100644
index 000000000..e207f9281
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES10/src/com/example/android/opengl/Triangle.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * A two-dimensional triangle for use as a drawn object in OpenGL ES 1.0/1.1.
+ */
+public class Triangle {
+
+    private final FloatBuffer vertexBuffer;
+
+    // number of coordinates per vertex in this array
+    static final int COORDS_PER_VERTEX = 3;
+    static float triangleCoords[] = {
+            // in counterclockwise order:
+            0.0f,  0.622008459f, 0.0f,// top
+           -0.5f, -0.311004243f, 0.0f,// bottom left
+            0.5f, -0.311004243f, 0.0f // bottom right
+    };
+
+    float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f };
+
+    /**
+     * Sets up the drawing object data for use in an OpenGL ES context.
+     */
+    public Triangle() {
+        // 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);
+    }
+
+    /**
+     * Encapsulates the OpenGL ES instructions for drawing this shape.
+     *
+     * @param gl - The OpenGL ES context in which to draw this shape.
+     */
+    public void draw(GL10 gl) {
+        // Since this shape uses vertex arrays, enable them
+        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+
+        // draw the shape
+        gl.glColor4f(       // set color:
+                color[0], color[1],
+                color[2], color[3]);
+        gl.glVertexPointer( // point to vertex data:
+                COORDS_PER_VERTEX,
+                GL10.GL_FLOAT, 0, vertexBuffer);
+        gl.glDrawArrays(    // draw shape:
+                GL10.GL_TRIANGLES, 0,
+                triangleCoords.length / COORDS_PER_VERTEX);
+
+        // Disable vertex array drawing to avoid
+        // conflicts with shapes that don't use it
+        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    }
+}
diff --git a/samples/OpenGL/HelloOpenGLES20/.gitignore b/samples/OpenGL/HelloOpenGLES20/.gitignore
new file mode 100644
index 000000000..ad7a3ead5
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/.gitignore
@@ -0,0 +1,9 @@
+# Files ignored for git source control
+#
+# Add this file to source control so the following files
+# are not tracked and added to git:
+.project
+.classpath
+project.properties
+bin/
+gen/
diff --git a/samples/OpenGL/HelloOpenGLES20/AndroidManifest.xml b/samples/OpenGL/HelloOpenGLES20/AndroidManifest.xml
new file mode 100644
index 000000000..af9a6bd05
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/AndroidManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.android.opengl"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk
+            android:minSdkVersion="8"
+            android:targetSdkVersion="17" />
+
+    <!-- Tell the system this app requires OpenGL ES 2.0. -->
+    <uses-feature android:glEsVersion="0x00020000" android:required="true" />
+
+    <application
+            android:icon="@drawable/ic_launcher"
+            android:label="@string/app_name"
+            android:allowBackup="true" >
+        <activity
+                android:name="com.example.android.opengl.OpenGLES20Activity"
+                android:label="@string/app_name" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/res/drawable/ic_launcher.png b/samples/OpenGL/HelloOpenGLES20/res/drawable/ic_launcher.png
new file mode 100644
index 000000000..359047dfa
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/res/drawable/ic_launcher.png
diff --git a/samples/OpenGL/HelloOpenGLES20/res/layout/main.xml b/samples/OpenGL/HelloOpenGLES20/res/layout/main.xml
new file mode 100644
index 000000000..7c7aee80d
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/res/layout/main.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<LinearLayout
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:orientation="vertical" >
+
+    <TextView
+            android:layout_width="fill_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/hello" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/res/values/strings.xml b/samples/OpenGL/HelloOpenGLES20/res/values/strings.xml
new file mode 100644
index 000000000..2b0821678
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/res/values/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 The Android Open Source Project.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+
+    <string name="hello">Hello, OpenGL ES 2.0!</string>
+    <string name="app_name">Hello OpenGL ES 2.0</string>
+
+</resources>
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLRenderer.java b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLRenderer.java
new file mode 100644
index 000000000..71f5b284e
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLRenderer.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+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.util.Log;
+
+/**
+ * Provides drawing instructions for a GLSurfaceView object. This class
+ * must override the OpenGL ES drawing lifecycle methods:
+ * <ul>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceCreated}</li>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onDrawFrame}</li>
+ *   <li>{@link android.opengl.GLSurfaceView.Renderer#onSurfaceChanged}</li>
+ * </ul>
+ */
+public class MyGLRenderer implements GLSurfaceView.Renderer {
+
+    private static final String TAG = "MyGLRenderer";
+    private Triangle mTriangle;
+    private Square   mSquare;
+
+    // mMVPMatrix is an abbreviation for "Model View Projection Matrix"
+    private final float[] mMVPMatrix = new float[16];
+    private final float[] mProjectionMatrix = new float[16];
+    private final float[] mViewMatrix = new float[16];
+    private final float[] mRotationMatrix = new float[16];
+
+    private float mAngle;
+
+    @Override
+    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
+
+        // Set the background frame color
+        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+        mTriangle = new Triangle();
+        mSquare   = new Square();
+    }
+
+    @Override
+    public void onDrawFrame(GL10 unused) {
+        float[] scratch = new float[16];
+
+        // Draw background color
+        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);
+
+        // Create a rotation for the triangle
+
+        // Use the following code to generate constant rotation.
+        // Leave this code out when using TouchEvents.
+        // long time = SystemClock.uptimeMillis() % 4000L;
+        // float angle = 0.090f * ((int) time);
+
+        Matrix.setRotateM(mRotationMatrix, 0, mAngle, 0, 0, 1.0f);
+
+        // Combine the rotation matrix with the projection and camera view
+        // Note that the mMVPMatrix factor *must be first* in order
+        // for the matrix multiplication product to be correct.
+        Matrix.multiplyMM(scratch, 0, mMVPMatrix, 0, mRotationMatrix, 0);
+
+        // Draw triangle
+        mTriangle.draw(scratch);
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 unused, int width, int height) {
+        // Adjust the viewport based on geometry changes,
+        // such as screen rotation
+        GLES20.glViewport(0, 0, width, height);
+
+        float ratio = (float) width / height;
+
+        // this projection matrix is applied to object coordinates
+        // in the onDrawFrame() method
+        Matrix.frustumM(mProjectionMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
+
+    }
+
+    /**
+     * Utility method for compiling a OpenGL shader.
+     *
+     * <p><strong>Note:</strong> When developing shaders, use the checkGlError()
+     * method to debug shader coding errors.</p>
+     *
+     * @param type - Vertex or fragment shader type.
+     * @param shaderCode - String containing the shader code.
+     * @return - Returns an id for the shader.
+     */
+    public static int loadShader(int type, String shaderCode){
+
+        // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
+        // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
+        int shader = GLES20.glCreateShader(type);
+
+        // add the source code to the shader and compile it
+        GLES20.glShaderSource(shader, shaderCode);
+        GLES20.glCompileShader(shader);
+
+        return shader;
+    }
+
+    /**
+    * Utility method for debugging OpenGL calls. Provide the name of the call
+    * just after making it:
+    *
+    * <pre>
+    * mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
+    * MyGLRenderer.checkGlError("glGetUniformLocation");</pre>
+    *
+    * If the operation is not successful, the check throws an error.
+    *
+    * @param glOperation - Name of the OpenGL call to check.
+    */
+    public static void checkGlError(String glOperation) {
+        int error;
+        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
+            Log.e(TAG, glOperation + ": glError " + error);
+            throw new RuntimeException(glOperation + ": glError " + error);
+        }
+    }
+
+    /**
+     * Returns the rotation angle of the triangle shape (mTriangle).
+     *
+     * @return - A float representing the rotation angle.
+     */
+    public float getAngle() {
+        return mAngle;
+    }
+
+    /**
+     * Sets the rotation angle of the triangle shape (mTriangle).
+     */
+    public void setAngle(float angle) {
+        mAngle = angle;
+    }
+
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLSurfaceView.java b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLSurfaceView.java
new file mode 100644
index 000000000..3782e17e9
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/MyGLSurfaceView.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.view.MotionEvent;
+
+/**
+ * A view container where OpenGL ES graphics can be drawn on screen.
+ * This view can also be used to capture touch events, such as a user
+ * interacting with drawn objects.
+ */
+public class MyGLSurfaceView extends GLSurfaceView {
+
+    private final MyGLRenderer mRenderer;
+
+    public MyGLSurfaceView(Context context) {
+        super(context);
+
+        // Create an OpenGL ES 2.0 context.
+        setEGLContextClientVersion(2);
+
+        // Set the Renderer for drawing on the GLSurfaceView
+        mRenderer = new MyGLRenderer();
+        setRenderer(mRenderer);
+
+        // Render the view only when there is a change in the drawing data
+        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
+    }
+
+    private final float TOUCH_SCALE_FACTOR = 180.0f / 320;
+    private float mPreviousX;
+    private float mPreviousY;
+
+    @Override
+    public boolean onTouchEvent(MotionEvent e) {
+        // MotionEvent reports input details from the touch screen
+        // and other input controls. In this case, you are only
+        // interested in events where the touch position changed.
+
+        float x = e.getX();
+        float y = e.getY();
+
+        switch (e.getAction()) {
+            case MotionEvent.ACTION_MOVE:
+
+                float dx = x - mPreviousX;
+                float dy = y - mPreviousY;
+
+                // reverse direction of rotation above the mid-line
+                if (y > getHeight() / 2) {
+                    dx = dx * -1 ;
+                }
+
+                // reverse direction of rotation to left of the mid-line
+                if (x < getWidth() / 2) {
+                    dy = dy * -1 ;
+                }
+
+                mRenderer.setAngle(
+                        mRenderer.getAngle() +
+                        ((dx + dy) * TOUCH_SCALE_FACTOR));  // = 180.0f / 320
+                requestRender();
+        }
+
+        mPreviousX = x;
+        mPreviousY = y;
+        return true;
+    }
+
+}
diff --git a/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/OpenGLES20Activity.java b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/OpenGLES20Activity.java
new file mode 100644
index 000000000..ab0f4406e
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/OpenGLES20Activity.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import android.app.Activity;
+import android.opengl.GLSurfaceView;
+import android.os.Bundle;
+
+public class OpenGLES20Activity extends Activity {
+
+    private GLSurfaceView mGLView;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Create a GLSurfaceView instance and set it
+        // as the ContentView for this Activity
+        mGLView = new MyGLSurfaceView(this);
+        setContentView(mGLView);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        // The following call pauses the rendering thread.
+        // If your OpenGL application is memory intensive,
+        // you should consider de-allocating objects that
+        // consume significant memory here.
+        mGLView.onPause();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        // The following call resumes a paused rendering thread.
+        // If you de-allocated graphic objects for onPause()
+        // this is a good place to re-allocate them.
+        mGLView.onResume();
+    }
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Square.java b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Square.java
new file mode 100644
index 000000000..87c09daad
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Square.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+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 Square {
+
+    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 Square() {
+        // 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 = MyGLRenderer.loadShader(
+                GLES20.GL_VERTEX_SHADER,
+                vertexShaderCode);
+        int fragmentShader = MyGLRenderer.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");
+        MyGLRenderer.checkGlError("glGetUniformLocation");
+
+        // Apply the projection and view transformation
+        GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
+        MyGLRenderer.checkGlError("glUniformMatrix4fv");
+
+        // Draw the square
+        GLES20.glDrawElements(
+                GLES20.GL_TRIANGLES, drawOrder.length,
+                GLES20.GL_UNSIGNED_SHORT, drawListBuffer);
+
+        // Disable vertex array
+        GLES20.glDisableVertexAttribArray(mPositionHandle);
+    }
+
+}
\ No newline at end of file
diff --git a/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Triangle.java b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Triangle.java
new file mode 100644
index 000000000..8359b45e1
--- /dev/null
+++ b/samples/OpenGL/HelloOpenGLES20/src/com/example/android/opengl/Triangle.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.opengl;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+import android.opengl.GLES20;
+
+/**
+ * A two-dimensional triangle for use as a drawn object in OpenGL ES 2.0.
+ */
+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
+            // 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 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 triangleCoords[] = {
+            // in counterclockwise order:
+            0.0f,  0.622008459f, 0.0f,   // top
+           -0.5f, -0.311004243f, 0.0f,   // bottom left
+            0.5f, -0.311004243f, 0.0f    // bottom right
+    };
+    private final int vertexCount = triangleCoords.length / COORDS_PER_VERTEX;
+    private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
+
+    float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f };
+
+    /**
+     * Sets up the drawing object data for use in an OpenGL ES context.
+     */
+    public Triangle() {
+        // 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 = MyGLRenderer.loadShader(
+                GLES20.GL_VERTEX_SHADER, vertexShaderCode);
+        int fragmentShader = MyGLRenderer.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");
+        MyGLRenderer.checkGlError("glGetUniformLocation");
+
+        // Apply the projection and view transformation
+        GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
+        MyGLRenderer.checkGlError("glUniformMatrix4fv");
+
+        // Draw the triangle
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
+
+        // Disable vertex array
+        GLES20.glDisableVertexAttribArray(mPositionHandle);
+    }
+
+}