Android音视频开发入门（六）

最新推荐文章于 2024-09-07 09:23:13 发布

LPF_FORFREE

最新推荐文章于 2024-09-07 09:23:13 发布

阅读量1.8k

点赞数 2

分类专栏： Android音视频入门文章标签： opengl学习 opengl绘制三角形 opengl绘制流程 opengl入门

本文链接：https://blog.csdn.net/jason_lewis/article/details/87640639

版权

Android音视频入门专栏收录该内容

10 篇文章 8 订阅

订阅专栏

1.任务目标

学习 Android 平台 OpenGL ES API，了解 OpenGL 开发的基本流程，使用 OpenGL 绘制一个三角形

2.OpenGL ES 基本介绍

Android的基本框架大家都不陌生，在Libraries层面包含了OpenGL，特别是OpenGL ES API支持高性能的2D和3D图形。OpenGL是一个跨平台的图形API，它为3D图形处理硬件指定了标准的软件接口。OpenGL ES是适用于嵌入式设备的OpenGL规范。Android支持如下几种OpenGL ES API版本：

OpenGL ES 1.0 and 1.1 - Android1.0及以上更高版本支持此规范
OpenGL ES 2.0 - Android2.2(API level 8)及以上更高版本支持此规范
OpenGL ES 3.0 - Android4.3(API level 18)及以上更高版本支持此规范
OpenGL ES 3.1 - Android 5.0 (API level 21)及以上更高版本支持此规范

注意： 在一个设备上支持OpenGL ES 3.0 API需要实现设备制造商提供的设备图形管道，运行Android4.3或者更低Android版本的设备可能不支持OpenGL ES 3.0。要检查支持什么版本的OpenGL ES请参考如下代码

private static double glVersion = 3.0;

private static class ContextFactory implements GLSurfaceView.EGLContextFactory {

  private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;

  public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {

      Log.w(TAG, "creating OpenGL ES " + glVersion + " context");
      int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, (int) glVersion, EGL10.EGL_NONE };
      // attempt to create a OpenGL ES 3.0 context
      EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
      return context; // returns null if 3.0 is not supported;
  }
}

如果createContext()方法返回null，说明此设备不支持OpenGL ES 3.0，需要重新创建一个OpenGL ES 2.0的上下文。还有OpenGL ES 3.0向后兼容2.0的API.

3.OpenGL ES 使用

Android框架中有两个基本的功能类GLSurfaceView和GLSurfaceView.Renderer，让你通过OpenGL ES API创建和操作图形。

3.1 GLSurfaceView

这是一个可以让你通过调用OpenGL ES API绘制和操作对象的View，其功能类似于SurfaceView。你可以通过这个类创建一个GLSurfaceView实例并给它添加你自己的Renderer。如果你想捕获屏幕的触摸事件，就要扩展GLSurfaceView类实现它的触摸监听了，下文绘制图形部分会介绍。

3.2 GLSurfaceView.Renderer

此接口定义了在GLSurfaceView中绘制的方法。你必须实现此接口作为单独的一个类使用，并使用GLSurfaceView.setRenderer()将此类添加到你的GLSurfaceView实例。
GLSurfaceView.Renderer接口需要实现下面几个方法：

onSurfaceCreated(): 创建GLSurfaceView时，系统调用一次该方法。使用此方法执行只需要发生一次的操作，例如设置 OpenGL 环境参数或者初始化 OpenGL 图形对象。
onDrawFrame(): 每次重绘 GLSurfaceView 时系统调用次方法。使用此方法作为绘制（或重新绘制）图形对象的主要方法。
onSurfaceChanged(): 当 GLSurfaceView 的几何图形发生变化时系统调用此方法，包括 GLSurfaceView 的大小或设备的屏幕方向改变。如设备从纵向变为横向时系统调用次方法。使用次方法响应 GLSurfaceView 容器的改变。

4.OpenGL ES 绘制图形

下面我们用OpenGL ES 2.0 API来绘制一个三角形，这也是当前绝大部分设备推荐使用的API版本。

4.1 构建OpenGL ES 环境

为了使用OpenGL ES 在你的应用程序中绘制图形，必须为它们创建一个视图容器。其中最直接的方式就是实现GLSurfaceView和 GLSurfaceView.Renderer。GLSurfaceView 是用 OpenGL 绘制图形的视图容器，GLSurfaceView.Renderer 控制在该视图内绘制的内容。
GLSurfaceView 是将图形合并到你应用程序中的一种方式。对于全屏或接近全屏的图形视图，这是一种合理的选择。想要在布局的一小部分添加 OpenGL ES 视图的开发人员应该看一下 TextureView。
下面使用 GLSurfaceView 和 GLSurfaceView.Renderer 在一个应用的Activity中做一个最简单的完整实现。

4.1.1 在Manifest中声明OpenGL ES使用

为了让你的应用程序能够使用OpenGL ES 2.0的API，你必须添加以下声明到manifest：

<uses-feature android:glEsVersion="0x00020000" android:required="true" />

如果你的应用程序需要使用纹理压缩，你还需要声明你的应用程序需要支持哪种压缩格式，以便他们安装在兼容的设备上。

<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" />
<supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />

关于更多的纹理压缩格式信息，请参考OpenGL开发者引导。

4.1.2 创建一个Activity 展示OpenGL ES 图形

使用OpenGL ES的应用程序的Activity和其他应用程的Activity一样，不同的地方是你 Activity 的布局设置，在许多其它的应用中你可能会使用 TextView, Button 和 ListView 等，但在使用 OpenGL ES 的APP中你还可以使用GLSurfaceView。
下面的代码展示了使用GLSurfaceView做为主视图的基本实现：

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);
    }
}

4.1.3 构建 GLSurfaceView 对象

GLSurfaceView 是一个特殊的View，在里面可以绘制 OpenGL ES 图形。它本身并没有做太多的事情。主要的绘制对象的控制是通过设置到此View的渲染器 GLSurfaceView.Renderer 实现的。实际上，创建这个对象的代码是很少的，你能会想尝试跳过extends的操作，只去创建一个没有被修改的GLSurfaceView实例，但是不建议这样去做。在某些情况下你需要继承这个类来捕获触摸事件，这个会在后面的文章里讲解。
GLSurfaceView的基本代码很少，为了快速的实现，通常会在使用它的Activity中创建一个内部类来做实现：

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(mRenderer);
    }
}

GLSurfaceView 实现的另一个可选操作是设置渲染模式为 GLSurfaceView.RENDERMODE_WHEN_DIRTY ，让它仅在绘制数据改变时进行绘制视图。

// Render the view only when there is a change in the drawing data
setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

这个设置可以防止 GLSurfaceView 重绘直到你调用 requestRender()方法, 这对于此app是更有效的。

4.1.4 构建一个Renderer类

这个类控制着与它关联的GLSurfaceView 绘制的内容。在renderer 里面有三个方法能够被Android系统调用，以便知道在 GLSurfaceView 上绘制什么以及如何绘制。

onSurfaceCreated() - 在View的OpenGL环境被创建的时候调用
onDrawFrame() - 每一次View的重绘都会调用
onSurfaceChanged() - 如果视图的几何形状发生变化（例如，当设备的屏幕方向改变时），则调用此方法

下面是使用OpenGL ES 渲染器的基本实现，仅仅做的事情就是在GLSurfaceView绘制一个黑色背景。

public class MyGLRenderer implements GLSurfaceView.Renderer {

    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
        // Set the background frame color
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    }

    public void onDrawFrame(GL10 unused) {
        // Redraw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
    }

    public void onSurfaceChanged(GL10 unused, int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }
}

4.2 定义图形

OpenGL ES允许你使用三维空间坐标系定义绘制的图像，所以你在绘制一个三角形之前必须要先定义它的坐标。在OpenGL中，这样做的典型方法是为坐标定义浮点数的顶点数组。为了获得最大的效率，可以将这些坐标写入ByteBuffer，并传递到OpenGL ES图形管道进行处理。

public class Triangle {

    private 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
    };

    // Set color with red, green, blue and alpha (opacity) values
    float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 1.0f };

    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);
    }
}

4.3 绘制图形

4.3.1 初始化形状

在你做任何绘制操作之前，你必须要初始化并加载你准备绘制的形状。除非形状的结构(指原始的坐标)在执行过程中发生改变，你都应该在你的Renderer的方法onSurfaceCreated()中进行内存和效率方面的初始化工作。

public class MyGLRenderer implements GLSurfaceView.Renderer {

    ...
    private Triangle mTriangle;
    private Square   mSquare;

    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
        ...
        // initialize a triangle
        mTriangle = new Triangle();
        // initialize a square
        mSquare = new Square();
    }
    ...
}

4.3.2 绘制形状

使用OpenGLES 2.0画一个定义好的形状需要比较多的代码，因为你必须为图形渲染管线提供一大堆信息。特别的，你必须定义以下几个东西：

Vertex Shader - 用于渲染形状的顶点的OpenGLES 图形代码
Fragment Shader - 用于渲染形状的外观（颜色或纹理）的OpenGLES 代码
Program - 一个OpenGLES对象，包含了你想要用来绘制一个或多个形状的shader

你至少需要一个vertexshader来绘制一个形状和一个fragmentshader来为形状上色。这些形状必须被编译然后被添加到一个OpenGLES program中，program之后被用来绘制形状。下面是一个展示如何定义一个可以用来绘制形状的基本shader的例子：

public class Triangle {

    private final String vertexShaderCode =
        "attribute vec4 vPosition;" +
        "void main() {" +
        "  gl_Position = vPosition;" +
        "}";

    private final String fragmentShaderCode =
        "precision mediump float;" +
        "uniform vec4 vColor;" +
        "void main() {" +
        "  gl_FragColor = vColor;" +
        "}";

    ...
}

Shader们包含了OpenGLShading Language (GLSL)代码，必须在使用前编译。要编译这些代码，在你的Renderer类中创建一个工具类方法：

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;
}

为了绘制你的形状，你必须编译shader代码，添加它们到一个OpenGLES program 对象然后链接这个program。在renderer对象的构造器中做这些事情，从而只需做一次即可。

注:编译OpenGLES shader们和链接linkingprogram们是很耗CPU的，所以你应该避免多次做这些事。如果在运行时你不知道shader的内容，你应该只创建一次code然后缓存它们以避免多次创建。

public class Triangle() {
    ...

    private final int mProgram;

    public Triangle() {
        ...

        int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER,
                                        vertexShaderCode);
        int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,
                                        fragmentShaderCode);

        // create empty OpenGL ES Program
        mProgram = GLES20.glCreateProgram();

        // add the vertex shader to program
        GLES20.glAttachShader(mProgram, vertexShader);

        // add the fragment shader to program
        GLES20.glAttachShader(mProgram, fragmentShader);

        // creates OpenGL ES program executables
        GLES20.glLinkProgram(mProgram);
    }
}

此时，你已经准备好增加真正的绘制调用了。需要为渲染管线指定很多参数来告诉它你想画什么以及如何画。因为绘制操作因形状而异，让你的形状类包含自己的绘制逻辑是个很好主意。

创建一个draw()方法负责绘制形状。下面的代码设置位置和颜色值到形状的vertexshader和fragmentshader，然后执行绘制功能:

private int mPositionHandle;
private int mColorHandle;

private final int vertexCount = triangleCoords.length / COORDS_PER_VERTEX;
private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex

public void draw() {
    // Add program to OpenGL ES 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);

    // Draw the triangle
    GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);

    // Disable vertex array
    GLES20.glDisableVertexAttribArray(mPositionHandle);
}

一旦完成了所有这些代码，绘制该对象只需要在渲染器的onDrawFrame（）方法中调用draw（）方法：

public void onDrawFrame(GL10 unused) {
    ...

    mTriangle.draw();
}

When you run the application, it should look something like this:
在这里插入图片描述

4.4 应用投影和相机视图

在OpenGL ES环境中，投影和摄像机视图允许您以更接近您用眼睛看物理对象的方式显示绘制对象。这种物理观察模拟是通过绘制对象坐标的数学变换完成的

Projection — 这个变换是基于他们所显示的GLSurfaceView的宽和高来调整绘制对象的坐标的。没有这个计算变换，通过OpenGL绘制的形状会在不同显示窗口变形。这个投影变化通常只会在OpenGL view的比例被确定或者在你渲染器的onSurfaceChanged()方法中被计算。想要了解更多的关于投影和坐标映射的相关信息，请看绘制对象的坐标映射。
Camera View — 这个换是基于虚拟的相机的位置来调整绘制对象坐标的。需要着重注意的是，OpenGL ES并没有定义一个真实的相机对象，而是提供一个实用方法，通过变换绘制对象的显示来模拟一个相机。相机视图变换可能只会在你的GLSurfaceView被确定时被计算，或者基于用户操作或你应用程序的功能来动态改变。

4.4.1 定义投影

投影变化的数据是在你GLSurfaceView.Renderer类的onSurfaceChanged()方法中被计算的。下面的示例代码是获取GLSurfaceView的高和宽，并通过Matrix.frustumM()方法用它们填充到投影变换矩阵中

// 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);

    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);
}

上面的代码填充有一个投影矩阵mProjectionMatrix，mProjectionMatrix可以在onFrameDraw()方法中与下一部分的相机视图结合在一起。

注意：如果仅仅只把投影矩阵应用的到你绘制的对象中，通常你只会得到一个非常空的显示。一般情况下，你还必须为你要在屏幕上显示的任何内容应用相机视图。

4.4.2 定义相机视图

通过在你的渲染器中添加相机视图变换作为你绘制过程的一部分来完成你的绘制图像的变换过程。在下面的代码中，通过Matrix.setLookAtM()方法计算相机视图变换，然后将其与之前计算出的投影矩阵结合到一起。合并后的矩阵接下来会传递给绘制的图形。

@Override
public void onDrawFrame(GL10 unused) {
    ...
    // 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 shape
    mTriangle.draw(mMVPMatrix);
}

4.4.3 应用投影和相机变换

为了使用在上一部分内容中展示的投影和相机视图变换的合并矩阵，首先要在之前Triangle类中定义的定点着色器代码中添加一个矩阵变量：

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;

    ...
}

下一步，修改你的图形对象的draw()方法来接收联合变换矩阵，并将它们应用到图形中：
public void draw(float[] mvpMatrix) { // pass in the calculated transformation matrix
…

// get handle to shape's transformation matrix
mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");

// Pass the projection and view transformation to the shader
GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);

// Draw the triangle
GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);

// Disable vertex array
GLES20.glDisableVertexAttribArray(mPositionHandle);

}
一旦你正确的计算并应用投影和相机视图变换，你的绘图对象将会以正确的比例绘制，它看起来应该像下面这样：
在这里插入图片描述

4.5 添加动作

在屏幕上绘制图形只是OpenGL的相当基础的特点，你也可以用其他的Android图形框架类来实现这些，包括Canvas和Drawable对象。OpenGL ES为在三维空间中移动和变换提供了额外的功能，并提供了创建引人注目的用户体验的独特方式。

4.5.1 旋转一个图形

用OpenGL ES 2.0来旋转一个绘制对象是相对简单的。在你的渲染器中，添加一个新的变换矩阵（旋转矩阵），然后把它与你的投影与相机视图变换矩阵合并到一起：

private float[] mRotationMatrix = new float[16];
Override
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);
    Matrix.setRotateM(mRotationMatrix, 0, angle, 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);
}

如果做了这些改变后你的三角形还没有旋转，请确保你是否注释掉了GLSurfaceView.RENDERMODE_WHEN_DIRTY设置项，这将在下一部分讲到。

4.5.2 允许连续渲染

如果你勤恳地遵循本系列课程的示例代码到这个点，请确保你注释了设置只有当dirty的时候才渲染的渲染模式这一行，否则OpenGL旋转图形，只会递增角度然后等待来自GLSurfaceView容器的对requestRender()方法的调用：

public MyGLSurfaceView(Context context) extends GLSurfaceView {
    ...
    // Render the view only when there is a change in the drawing data.
    // To allow the triangle to rotate automatically, this line is commented out:
    //setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}

4.6 响应触摸事件

像旋转三角形一样，通过预设程序来让对象移动对于吸引注意是很有用的，但是如果你想让你的OpenGL图形有用户交互呢？让你的OpenGL ES应用有触摸交互的关键是，扩展你的GLSurfaceView的实现重载onTouchEvent()方法来监听触摸事件。
本节内容将向你展示如何监听触摸事件来让用户旋转一个图形。

4.6.1 设置触摸事件

为了你的OpenGL ES应用能够响应触摸事件，你必须在你的GLSurfaceView中实现onTouchEvent()方法，下面的实现例子展示了怎样监听MotionEvent.ACTION_MOVE事件，并将该事件转换成图形的旋转角度。

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));
            requestRender();
    }

    mPreviousX = x;
    mPreviousY = y;
    return true;
}

需要注意的是，计算完旋转角度后，需要调用requestRender()方法来告诉渲染器是时候渲染帧画面了。在本例子中这种方法是最高效的，因为除非旋转有改变，否则帧画面不需要重绘。然而除非你还用setRenderMode()方法要求渲染器只有在数据改变时才进行重绘，否则这对性能没有任何影响。因此，确保渲染器中的下面这行是取消注释的：

public MyGLSurfaceView(Context context) {
    ...
    // Render the view only when there is a change in the drawing data
    setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}

4.6.2 暴露旋转角度

上面的例程代码中需要你通过在渲染器中添加共有的成员来暴露旋转角度。当渲染代码是在独立于你应用程序的主用户界面线程的单独线程执行的时候，你必须声明这个共有变量是volatile类型的。下面的代码声明了这个变量并且暴露了它的getter和setter方法对：

public class MyGLRenderer implements GLSurfaceView.Renderer {
    ...

    public volatile float mAngle;

    public float getAngle() {
        return mAngle;
    }

    public void setAngle(float angle) {
        mAngle = angle;
    }
}

4.6.3 应用旋转

为了应用触摸输入产生的旋转，先注释掉产生角度的代码，并添加一个右触摸事件产生的角度mAngle：

public void onDrawFrame(GL10 gl) {
    ...
    float[] scratch = new float[16];

    // Create a rotation for the triangle
    // 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);
}

当你完成上面介绍的步骤，运行你的程序，然后在屏幕上拖拽你的手指来旋转这个三角形。
在这里插入图片描述
代码已上传GitHub