如何在 Android Ice Cream Sandwich 中用 TextureView 替换 GLSurfaceView？

Question

TextureView documentation 声明它可用于渲染 OpenGL 内容。

在宣布 TextureView 的blog post 中，它声明：

TextureView 可以很容易地用于在您的应用程序中嵌入 OpenGL 场景。从 Android 4.0 开始，可以使用 eglCreateWindowSurface() 渲染到 SurfaceTexture 对象中。

这似乎意味着要使用 TextureView 而不是 GLSurfaceView，必须自己完成所有 EGL 设置并管理 EGLContext 和线程（因为 GLSurfaceView 维护一个 GLThread）。 Android 4.0 SDK 中似乎没有任何示例代码演示“TextureView 可以很容易地用于嵌入 OpenGL 场景”。 TextureView 似乎更干净地插入到相机预览 (setPreviewTexture) 和 MediaPlayer (setSurface)。

是否可以通过使用 GLSurfaceView.setEGLWindowSurfaceFactory 将 GLSurfaceView 与 TextureView 结合使用，使其渲染到 TextureView 的 SurfaceTexture？

同样，如果有一些示例代码就好了。

Answer 1

版主删除了此答案，因此将其添加回来以供后代使用：

查看来自 android-dev google 组的 Romain Guy 的回答（2011 年 11 月 23 日）：

http://groups.google.com/group/android-developers/browse_thread/thread/539457146a401cf1（镜像：http://grokbase.com/t/gg/android-developers/11bqmgb7sw/how-to-replace-glsurfaceview-with-textureview-in-android-ice-cream-sandwich）

GLSurfaceView 会为您处理 GL 设置，TextureView 不会这样做。 创建 EGL 时，可以将 TextureView 用作本机窗口 表面。这是一个例子（有趣的部分是调用 eglCreateWindowSurface()):

 @Override
 public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
     mRenderThread = new RenderThread(getResources(), surface);
     mRenderThread.start();
 }

 private static class RenderThread extends Thread {
     private static final String LOG_TAG = "GLTextureView";

     static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
     static final int EGL_OPENGL_ES2_BIT = 4;

     private volatile boolean mFinished;

     private final Resources mResources;
     private final SurfaceTexture mSurface;

     private EGL10 mEgl;
     private EGLDisplay mEglDisplay;
     private EGLConfig mEglConfig;
     private EGLContext mEglContext;
     private EGLSurface mEglSurface;
     private GL mGL;

     RenderThread(Resources resources, SurfaceTexture surface) {
         mResources = resources;
         mSurface = surface;
     }

     private static final String sSimpleVS =
             "attribute vec4 position;\n" +
             "attribute vec2 texCoords;\n" +
             "varying vec2 outTexCoords;\n" +
             "\nvoid main(void) {\n" +
             " outTexCoords = texCoords;\n" +
             " gl_Position = position;\n" +
             "}\n\n";
     private static final String sSimpleFS =
             "precision mediump float;\n\n" +
             "varying vec2 outTexCoords;\n" +
             "uniform sampler2D texture;\n" +
             "\nvoid main(void) {\n" +
             " gl_FragColor = texture2D(texture, outTexCoords);\n" +
             "}\n\n";

     private static final int FLOAT_SIZE_BYTES = 4;
     private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
     private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;
     private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;
     private final float[] mTriangleVerticesData = {
             // X, Y, Z, U, V
             -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
              1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
             -1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
              1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
     };

     @Override
     public void run() {
         initGL();

         FloatBuffer triangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.length * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer();
         triangleVertices.put(mTriangleVerticesData).position(0);

         int texture = loadTexture(R.drawable.large_photo);
         int program = buildProgram(sSimpleVS, sSimpleFS);

         int attribPosition = glGetAttribLocation(program, "position");
         checkGlError();

         int attribTexCoords = glGetAttribLocation(program, "texCoords");
         checkGlError();

         int uniformTexture = glGetUniformLocation(program, "texture");
         checkGlError();

         glBindTexture(GL_TEXTURE_2D, texture);
         checkGlError();

         glUseProgram(program);
         checkGlError();

         glEnableVertexAttribArray(attribPosition);
         checkGlError();

         glEnableVertexAttribArray(attribTexCoords);
         checkGlError();

         glUniform1i(uniformTexture, texture);
         checkGlError();

         while (!mFinished) {
             checkCurrent();

             glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
             checkGlError();

             glClear(GL_COLOR_BUFFER_BIT);
             checkGlError();

             // drawQuad

             triangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
             glVertexAttribPointer(attribPosition, 3, GL_FLOAT, false,
                     TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);

             triangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
             glVertexAttribPointer(attribTexCoords, 3, GL_FLOAT, false,
                     TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);

             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

             if (!mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
                 throw new RuntimeException("Cannot swap buffers");
             }
             checkEglError();

             try {
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 // Ignore
             }
         }

         finishGL();
     }

     private int loadTexture(int resource) {
         int[] textures = new int[1];

         glActiveTexture(GL_TEXTURE0);
         glGenTextures(1, textures, 0);
         checkGlError();

         int texture = textures[0];
         glBindTexture(GL_TEXTURE_2D, texture);
         checkGlError();

         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

         Bitmap bitmap = BitmapFactory.decodeResource(mResources, resource);

         GLUtils.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap, GL_UNSIGNED_BYTE, 0);
         checkGlError();

         bitmap.recycle();

         return texture;
     }

     private int buildProgram(String vertex, String fragment) {
         int vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
         if (vertexShader == 0) return 0;

         int fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
         if (fragmentShader == 0) return 0;

         int program = glCreateProgram();
         glAttachShader(program, vertexShader);
         checkGlError();

         glAttachShader(program, fragmentShader);
         checkGlError();

         glLinkProgram(program);
         checkGlError();

         int[] status = new int[1];
         glGetProgramiv(program, GL_LINK_STATUS, status, 0);
         if (status[0] != GL_TRUE) {
             String error = glGetProgramInfoLog(program);
             Log.d(LOG_TAG, "Error while linking program:\n" + error);
             glDeleteShader(vertexShader);
             glDeleteShader(fragmentShader);
             glDeleteProgram(program);
             return 0;
         }

         return program;
     }

     private int buildShader(String source, int type) {
         int shader = glCreateShader(type);

         glShaderSource(shader, source);
         checkGlError();

         glCompileShader(shader);
         checkGlError();

         int[] status = new int[1];
         glGetShaderiv(shader, GL_COMPILE_STATUS, status, 0);
         if (status[0] != GL_TRUE) {
             String error = glGetShaderInfoLog(shader);
             Log.d(LOG_TAG, "Error while compiling shader:\n" + error);
             glDeleteShader(shader);
             return 0;
         }

         return shader;
     }

     private void checkEglError() {
         int error = mEgl.eglGetError();
         if (error != EGL10.EGL_SUCCESS) {
             Log.w(LOG_TAG, "EGL error = 0x" + Integer.toHexString(error));
         }
     }

     private void checkGlError() {
         int error = glGetError();
         if (error != GL_NO_ERROR) {
             Log.w(LOG_TAG, "GL error = 0x" + Integer.toHexString(error));
         }
     }

     private void finishGL() {
         mEgl.eglDestroyContext(mEglDisplay, mEglContext);
         mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
     }

     private void checkCurrent() {
         if (!mEglContext.equals(mEgl.eglGetCurrentContext()) ||

         !mEglSurface.equals(mEgl.eglGetCurrentSurface(EGL10.EGL_DRAW))) {
             if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
                 throw new RuntimeException("eglMakeCurrent failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
             }
         }
     }

     private void initGL() {
         mEgl = (EGL10) EGLContext.getEGL();

         mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
         if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
             throw new RuntimeException("eglGetDisplay failed "
                     + GLUtils.getEGLErrorString(mEgl.eglGetError()));
         }

         int[] version = new int[2];
         if (!mEgl.eglInitialize(mEglDisplay, version)) {
             throw new RuntimeException("eglInitialize failed " +
                     GLUtils.getEGLErrorString(mEgl.eglGetError()));
         }

         mEglConfig = chooseEglConfig();
         if (mEglConfig == null) {
             throw new RuntimeException("eglConfig not initialized");
         }

         mEglContext = createContext(mEgl, mEglDisplay, mEglConfig);

         mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, mSurface, null);

         if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE)
         {
             int error = mEgl.eglGetError();
             if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
                 Log.e(LOG_TAG, "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
                 return;
             }
             throw new RuntimeException("createWindowSurface failed "
                     + GLUtils.getEGLErrorString(error));
         }

         if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
             throw new RuntimeException("eglMakeCurrent failed "
                     + GLUtils.getEGLErrorString(mEgl.eglGetError()));
         }

         mGL = mEglContext.getGL();
     }


     EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
         int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
         return egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
     }

     private EGLConfig chooseEglConfig() {
         int[] configsCount = new int[1];
         EGLConfig[] configs = new EGLConfig[1];
         int[] configSpec = getConfig();
         if (!mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, configsCount)) {
             throw new IllegalArgumentException("eglChooseConfig failed " +
                     GLUtils.getEGLErrorString(mEgl.eglGetError()));
         } else if (configsCount[0] > 0) {
             return configs[0];
         }
         return null;
     }

     private int[] getConfig() {
         return new int[] {
                 EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                 EGL10.EGL_RED_SIZE, 8,
                 EGL10.EGL_GREEN_SIZE, 8,
                 EGL10.EGL_BLUE_SIZE, 8,
                 EGL10.EGL_ALPHA_SIZE, 8,
                 EGL10.EGL_DEPTH_SIZE, 0,
                 EGL10.EGL_STENCIL_SIZE, 0,
                 EGL10.EGL_NONE
         };
     }

     void finish() {
         mFinished = true;
     }
 }

Answer 2

正如@fadden 前面提到的，您在这里有一个使用TextureView 的好例子：https://github.com/google/grafika/blob/master/src/com/android/grafika/TextureViewGLActivity.java。

GLSurfaceView 和 TextureView 是互斥的。我没有看到同时拥有两者的用例。