Once you have all this code in place, drawing this object just requires a call to the {@code draw()} method from within your renderer’s {@link -android.opengl.GLSurfaceView.Renderer#onDrawFrame onDrawFrame()} method. When you run the -application, it should look something like this:
+android.opengl.GLSurfaceView.Renderer#onDrawFrame onDrawFrame()} method: + +
+public void onDrawFrame(GL10 unused) {
+ ...
+
+ mTriangle.draw();
+}
+
+
+When you run the application, it should look something like this:
diff --git a/docs/html/training/graphics/opengl/environment.jd b/docs/html/training/graphics/opengl/environment.jd index 6b00c764f5e09..cf2b64ad80003 100644 --- a/docs/html/training/graphics/opengl/environment.jd +++ b/docs/html/training/graphics/opengl/environment.jd @@ -129,28 +129,22 @@ just create an inner class in the activity that uses it:
class MyGLSurfaceView extends GLSurfaceView {
+ private final MyGLRenderer mRenderer;
+
public MyGLSurfaceView(Context context){
super(context);
+ // Create an OpenGL ES 2.0 context
+ setEGLContextClientVersion(2);
+
+ mRenderer = new MyGLRenderer();
+
// Set the Renderer for drawing on the GLSurfaceView
- setRenderer(new MyRenderer());
+ setRenderer(mRenderer);
}
}
-When using OpenGL ES 2.0, you must add another call to your {@link android.opengl.GLSurfaceView} -constructor, specifying that you want to use the 2.0 API:
- --// Create an OpenGL ES 2.0 context -setEGLContextClientVersion(2); -- -
Note: If you are using the OpenGL ES 2.0 API, make sure you declare -this in your application manifest. For more information, see Declare OpenGL ES -Use -in the Manifest.
-One other optional addition to your {@link android.opengl.GLSurfaceView} implementation is to set the render mode to only draw the view when there is a change to your drawing data using the {@link android.opengl.GLSurfaceView#RENDERMODE_WHEN_DIRTY GLSurfaceView.RENDERMODE_WHEN_DIRTY} @@ -186,7 +180,7 @@ the geometry of the view changes, for example when the device's screen orientati
Here is a very basic implementation of an OpenGL ES renderer, that does nothing more than draw a -gray background in the {@link android.opengl.GLSurfaceView}:
+black background in the {@link android.opengl.GLSurfaceView}:
public class MyGLRenderer implements GLSurfaceView.Renderer {
@@ -208,7 +202,7 @@ public class MyGLRenderer implements GLSurfaceView.Renderer {
That’s all there is to it! The code examples above create a simple Android application that -displays a gray screen using OpenGL. While this code does not do anything very interesting, by +displays a black screen using OpenGL. While this code does not do anything very interesting, by creating these classes, you have laid the foundation you need to start drawing graphic elements with OpenGL.
diff --git a/docs/html/training/graphics/opengl/motion.jd b/docs/html/training/graphics/opengl/motion.jd index fbcdd7fdfcc08..b026a4a31dbb0 100644 --- a/docs/html/training/graphics/opengl/motion.jd +++ b/docs/html/training/graphics/opengl/motion.jd @@ -45,16 +45,17 @@ to a shape with rotation.Rotate a Shape
-Rotating a drawing object with OpenGL ES 2.0 is relatively simple. You create another -transformation matrix (a rotation matrix) and then combine it with your projection and +
Rotating a drawing object with OpenGL ES 2.0 is relatively simple. In your renderer, create +another transformation matrix (a rotation matrix) and then combine it with your projection and camera view transformation matrices:
private float[] mRotationMatrix = new float[16];
public void onDrawFrame(GL10 gl) {
- ...
float[] scratch = new float[16];
+ ...
+
// Create a rotation transformation for the triangle
long time = SystemClock.uptimeMillis() % 4000L;
float angle = 0.090f * ((int) time);
diff --git a/docs/html/training/graphics/opengl/projection.jd b/docs/html/training/graphics/opengl/projection.jd
index b09e74ce61ea4..356d5d42b792f 100644
--- a/docs/html/training/graphics/opengl/projection.jd
+++ b/docs/html/training/graphics/opengl/projection.jd
@@ -71,6 +71,11 @@ projection transformation {@link android.opengl.Matrix} using the {@link
android.opengl.Matrix#frustumM Matrix.frustumM()} method:
+// 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];
+
@Override
public void onSurfaceChanged(GL10 unused, int width, int height) {
GLES20.glViewport(0, 0, width, height);
@@ -95,10 +100,10 @@ view transformation in order for anything to show up on screen.
Define a Camera View
Complete the process of transforming your drawn objects by adding a camera view transformation as
-part of the drawing process. In the following example code, the camera view transformation is
-calculated using the {@link android.opengl.Matrix#setLookAtM Matrix.setLookAtM()} method and then
-combined with the previously calculated projection matrix. The combined transformation matrices
-are then passed to the drawn shape.
+part of the drawing process in your renderer. In the following example code, the camera view
+transformation is calculated using the {@link android.opengl.Matrix#setLookAtM Matrix.setLookAtM()}
+method and then combined with the previously calculated projection matrix. The combined
+transformation matrices are then passed to the drawn shape.
@Override
@@ -119,7 +124,32 @@ public void onDrawFrame(GL10 unused) {
Apply Projection and Camera Transformations
In order to use the combined projection and camera view transformation matrix shown in the
-previews sections, modify the {@code draw()} method of your graphic objects to accept the combined
+previews sections, first add a matrix variable to the vertex shader previously defined
+in the Triangle class:
+
+
+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;" +
+ "}";
+
+ // Use to access and set the view transformation
+ private int mMVPMatrixHandle;
+
+ ...
+}
+
+
+Next, modify the {@code draw()} method of your graphic objects to accept the combined
transformation matrix and apply it to the shape:
@@ -127,14 +157,16 @@ public void draw(float[] mvpMatrix) { // pass in the calculated transformation m
...
// get handle to shape's transformation matrix
- mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
+ mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
// Pass the projection and view transformation to the shader
- GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
+ GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
// Draw the triangle
GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
- ...
+
+ // Disable vertex array
+ GLES20.glDisableVertexAttribArray(mPositionHandle);
}
diff --git a/docs/html/training/graphics/opengl/touch.jd b/docs/html/training/graphics/opengl/touch.jd
index 4c9f0c77be554..089ede7b63dac 100644
--- a/docs/html/training/graphics/opengl/touch.jd
+++ b/docs/html/training/graphics/opengl/touch.jd
@@ -50,6 +50,10 @@ android.opengl.GLSurfaceView#onTouchEvent onTouchEvent()} to listen for touch ev
an angle of rotation for a shape.
+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
@@ -77,7 +81,7 @@ public boolean onTouchEvent(MotionEvent e) {
mRenderer.setAngle(
mRenderer.getAngle() +
- ((dx + dy) * TOUCH_SCALE_FACTOR); // = 180.0f / 320
+ ((dx + dy) * TOUCH_SCALE_FACTOR));
requestRender();
}
@@ -108,12 +112,22 @@ public MyGLSurfaceView(Context context) {
The example code above requires that you expose the rotation angle through your renderer by
adding a public member. Since the renderer code is running on a separate thread from the main user
interface thread of your application, you must declare this public variable as {@code volatile}.
-Here is the code to do that:
+Here is the code to declare the variable and expose the getter and setter pair:
public class MyGLRenderer implements GLSurfaceView.Renderer {
...
+
public volatile float mAngle;
+
+ public float getAngle() {
+ return mAngle;
+ }
+
+ public void setAngle(float angle) {
+ mAngle = angle;
+ }
+}