`

TextureView展示OpenGL内容(Demo)

阅读更多


 

        上图的实现,如果是用GLSurfaceView实现,那会相对比较简单,直接在设置的Renderer实现类中实现gl展示即可,但是使用TextureView就没那么方便了,一般TextureView与OpenGL和结合就是相机预览和视频播放了,那如果是一般的gles展示呢? 这就需要重新创建一个GL线程了(相比之下,这种方式是真真不好的,通过实践发现:这种实现方式CPU占用率比GLSurfaceView的CPU占用率还高。再者GLSurfaceView本就对渲染同步、状态控制等做了优化封装),但既然已经做了,就写下来mark一下!

        那这个demo主要有3个类,主要看代码,代码中有注释。

1.GLESTextureView,这个类继承自TextureView,主要是添加了setRenderer和setRenderMode方法,使其用起来像GLSurfaceView一样。

2.GLESTVThread,这是一个线程类,在GLESTextureView的SurfaceTexture准备好之后开启该线程作为一个GL线程(GL的一些操作都要在该线程中去实现)。

3.IGLESRenderer,该类是GL线程流程的接口,该接口的实现可用于GLESTextureView的setRenderer,也可以用于GLSurfaceView中的renderer的方法体实现。

 

package com.dandy.helper.gles;

/**
 * <pre>
 * GLES里用到的用于渲染的一个接口。
 * 如果是GLSurfaceView要用到,则其对应的GLSurfaceView.Renderer可以来调用IGLESRenderer的实现类来实现逻辑
 * 如果是TextureView要用到,则使用自定义的一个线程里调用IGLESRenderer的实现类来做一个类似于GLSurfaceView.Renderer的操作
 * 所以IGLESRenderer中的方法都要在GL线程里运行(TextureView创建一个线程,把它当做一个GL线程)
 * </pre>
 * 
 * @author flycatdeng
 * 
 */
public interface IGLESRenderer {
    /**
     * <pre>
     * Surface创建好之后
     * </pre>
     */
    public void onSurfaceCreated();

    /**
     * <pre>
     * 界面大小有更改
     * </pre>
     * 
     * @param width
     * @param height
     */
    public void onSurfaceChanged(int width, int height);

    /**
     * <pre>
     * 绘制每一帧
     * </pre>
     */
    public void onDrawFrame();

    /**
     * <pre>
     * Activity的onResume时的操作
     * </pre>
     */
    public void onResume();

    /**
     * <pre>
     * Activity的onPause时的操作
     * </pre>
     */
    public void onPause();

    /**
     * <pre>
     * Activity的onDestroy时的操作
     * </pre>
     */
    public void onDestroy();

}

 

package com.dandy.module.gles.textureview;

import android.content.Context;
import android.graphics.SurfaceTexture;
import android.util.AttributeSet;
import android.view.TextureView;

import com.dandy.helper.gles.IGLESRenderer;

/**
 * <pre>
 * 一个类似于GLSurfaceView的TextureView,用于显示opengl
 *  {@link #setRenderer(IGLESRenderer)}类似于GLSurfaceView的setRenderer(Renderer)
 *  {{@link #setRenderMode(int)}类似于GLSurfaceView的setRenderMode(int)
 *  详细调用可模仿com.dandy.gldemo.glestextureview.DemoGlesTextureView
 *  没事可看<a href='http://blog.csdn.net/fuyajun01/article/details/8931647#' >参照1</>或者<a href="http://www.jianshu.com/p/b2d949ab1a1a">参照2</a>
 * </pre>
 * 
 * @author flycatdeng
 * 
 */
public class GLESTextureView extends TextureView implements TextureView.SurfaceTextureListener {
    public final static int RENDERMODE_WHEN_DIRTY = 0;
    public final static int RENDERMODE_CONTINUOUSLY = 1;
    private GLESTVThread mGLThread;
    private IGLESRenderer mRenderer;
    private int mRendererMode = RENDERMODE_CONTINUOUSLY;

    public GLESTextureView(Context context) {
        super(context);
        init(context);
    }

    public GLESTextureView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    /**
     * <pre>
     * 类似于GLSurfaceView的setRenderer
     * </pre>
     */
    public void setRenderer(IGLESRenderer renderer) {
        mRenderer = renderer;
    }

    /**
     * <pre>
     * 类似于GLSurfaceView的setRenderMode
     * 渲染模式,是循环刷新,还是请求的时候刷新
     * </pre>
     */
    public void setRenderMode(int mode) {
        mRendererMode = mode;
    }

    /**
     * Request that the renderer render a frame. This method is typically used when the render mode has been set to {@link #RENDERMODE_WHEN_DIRTY}, so
     * that frames are only rendered on demand. May be called from any thread. Must not be called before a renderer has been set.
     */
    public void requestRender() {
        if (mRendererMode != RENDERMODE_WHEN_DIRTY) {
            return;
        }
        mGLThread.requestRender();
    }

    private void init(Context context) {
        setSurfaceTextureListener(this);
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        mGLThread = new GLESTVThread(surface, mRenderer);// 创建一个线程,作为GL线程
        mGLThread.setRenderMode(mRendererMode);
        mGLThread.start();
        mGLThread.onSurfaceChanged(width, height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        return false;
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
        mGLThread.onSurfaceChanged(width, height);
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

    }

    public void onResume() {
        if (mGLThread != null) {
            mGLThread.onResume();
        }
    }

    public void onPause() {
        if (mGLThread != null) {
            mGLThread.onPause();
        }
    }

    public void onDestroy() {
        if (mGLThread != null) {
            mGLThread.onDestroy();
        }
    }
}

 

package com.dandy.module.gles.textureview;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;

import android.graphics.SurfaceTexture;
import android.opengl.GLUtils;

import com.dandy.helper.android.LogHelper;
import com.dandy.helper.gles.IGLESRenderer;
import com.dandy.helper.java.PendingThreadAider;

/**
 * <pre>
 * TextureView中要用的GLThread
 * <a href="http://www.cnblogs.com/kiffa/archive/2013/02/21/2921123.html">一个很好的EGL相关学习参考</a>
 * 一般在Android中使用OpenGL ES,总是会从GLSurfaceView和Renderer开始,只需要提供一个合适的SurfaceHolder,就可以完成整个环境初始化,并进行绘制。
 * GLSurfaceView和Renderer事实上只是在本文描述的基础上封装了一些便利的功能,便于开发者开发,比如渲染同步、状态控制、主(渲染)循环等
 * </pre>
 * 
 * @author flycatdeng
 */
class GLESTVThread extends Thread {
    private static final String TAG = "GLESTVThread";
    private SurfaceTexture mSurfaceTexture;
    private EGL10 mEgl;
    private EGLDisplay mEglDisplay = EGL10.EGL_NO_DISPLAY;// 显示设备
    private EGLSurface mEglSurface = EGL10.EGL_NO_SURFACE;
    private EGLContext mEglContext = EGL10.EGL_NO_CONTEXT;
//    private GL mGL;
    private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
    private static final int EGL_OPENGL_ES2_BIT = 4;
    private IGLESRenderer mRenderer;
    private PendingThreadAider mPendingThreadAider = new PendingThreadAider();
    private boolean mNeedRenderring = true;
    private Object LOCK = new Object();
    private boolean mIsPaused = false;

    public GLESTVThread(SurfaceTexture surface, IGLESRenderer renderer) {
        mSurfaceTexture = surface;
        mRenderer = renderer;
    }

    @Override
    public void run() {
        LogHelper.d(TAG, LogHelper.getThreadName());
        initGLESContext();
        mRenderer.onSurfaceCreated();
        while (mNeedRenderring) {
            mPendingThreadAider.runPendings();// 执行未执行的,或要执行的事件。(后期可以开放以便模仿GLSurfaceView的queueEvent(Runnable r))
            mRenderer.onDrawFrame();// 绘制
            // 一帧完成之后,调用eglSwapBuffers(EGLDisplay dpy, EGLContext ctx)来显示
            mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);// 这一句不能少啊,少了就GG了,一片空白
            // 1.凡是onPause都要停止,2.如果是onResume的状态,如果是循环刷新则会继续下一次循环,否则会暂停等待调用requestRender()
            if (mIsPaused) {
                pauseWhile();
            } else if (mRendererMode == GLESTextureView.RENDERMODE_WHEN_DIRTY) {
                pauseWhile();
            }
        }
        destoryGLESContext();
    }

    private void initGLESContext() {
        LogHelper.d(TAG, LogHelper.getThreadName());
        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)) {// //version中存放EGL 版本号,int[0]为主版本号,int[1]为子版本号
            throw new RuntimeException("eglInitialize failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
        }

        // 构造需要的特性列表
        int[] configAttribs = { //
        EGL10.EGL_BUFFER_SIZE, 32,//
                EGL10.EGL_ALPHA_SIZE, 8, // 指定Alpha大小,以下四项实际上指定了像素格式
                EGL10.EGL_BLUE_SIZE, 8, // 指定B大小
                EGL10.EGL_GREEN_SIZE, 8,// 指定G大小
                EGL10.EGL_RED_SIZE, 8,// 指定RGB中的R大小(bits)
                EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,// 指定渲染api类别,这里或者是硬编码的4,或者是EGL14.EGL_OPENGL_ES2_BIT
                EGL10.EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT, EGL10.EGL_NONE// 总是以EGL10.EGL_NONE结尾
        };

        int[] numConfigs = new int[1];
        EGLConfig[] configs = new EGLConfig[1];
        // eglChooseConfig(display, attributes, configs, num, configNum);
        // 用于获取满足attributes的所有config,参数1、2其意明显,参数3用于存放输出的configs,参数4指定最多输出多少个config,参数5由EGL系统写入,表明满足attributes的config一共有多少个
        if (!mEgl.eglChooseConfig(mEglDisplay, configAttribs, configs, 1, numConfigs)) {// 获取所有满足attributes的configs,并选择一个
            throw new RuntimeException("eglChooseConfig failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
        }

        int[] contextAttribs = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};// attrib_list,目前可用属性只有EGL_CONTEXT_CLIENT_VERSION, 1代表OpenGL ES 1.x,
                                                                                // 2代表2.0。同样在Android4.2之前,没有EGL_CONTEXT_CLIENT_VERSION这个属性,只能使用硬编码0x3098代替
        mEglContext = mEgl.eglCreateContext(mEglDisplay, configs[0], EGL10.EGL_NO_CONTEXT, // share_context,是否有context共享,共享的contxt之间亦共享所有数据。EGL_NO_CONTEXT代表不共享
                contextAttribs);// 创建context
        mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, configs[0], mSurfaceTexture,// 负责对Android Surface的管理
                null// Surface属性
                );// 获取显存,create a new EGL window surface
        if (mEglSurface == EGL10.EGL_NO_SURFACE || mEglContext == EGL10.EGL_NO_CONTEXT) {
            int error = mEgl.eglGetError();
            if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
                throw new RuntimeException("eglCreateWindowSurface returned  EGL_BAD_NATIVE_WINDOW. ");
            }
            throw new RuntimeException("eglCreateWindowSurface failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
        }

        if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {// 设置为当前的渲染环境
            throw new RuntimeException("eglMakeCurrent failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
        }
//        mGL = mEglContext.getGL();
    }

    private void pauseWhile() {
        synchronized (LOCK) {
            try {
                LOCK.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void destoryGLESContext() {
        LogHelper.d(TAG, LogHelper.getThreadName());
        mEgl.eglDestroyContext(mEglDisplay, mEglContext);
        mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
        mEglContext = EGL10.EGL_NO_CONTEXT;
        mEglSurface = EGL10.EGL_NO_SURFACE;
    }

    public void onPause() {
        mRenderer.onPause();
        mIsPaused = true;
    }

    public void onResume() {
        mRenderer.onResume();
        mIsPaused = false;
        requestRender();
    }

    public void onSurfaceChanged(final int width, final int height) {
        mPendingThreadAider.addToPending(new Runnable() {// 在GL线程中执行

                    @Override
                    public void run() {
                        mRenderer.onSurfaceChanged(width, height);
                    }
                });
    }

    private int mRendererMode = GLESTextureView.RENDERMODE_CONTINUOUSLY;

    public void setRenderMode(int mode) {
        mRendererMode = mode;
    }

    public void requestRender() {
        synchronized (LOCK) {
            LOCK.notifyAll();
        }
    }

    public void onDestroy() {
        mNeedRenderring = false;
        mRenderer.onDestroy();
        destoryGLESContext();
    }
}

 

demo:https://github.com/flycatdeng/GLTextureViewDemo

 

一个Activity里两个GLSurfaceView无法同时渲染,所以如果要分多个区渲染的话,这个TextureView倒也可以去用用

http://stackoverflow.com/questions/4991095/how-can-i-use-multiple-glsurfaceview-components-in-the-same-layout

  • 大小: 204 KB
1
0
分享到:
评论

相关推荐

    SurfaceView TextureView的Demo

    `TextureView`则是一个可以嵌入到布局中的2D纹理视图,它通过OpenGL ES在硬件加速的渲染管道中提供一个可操作的纹理。`TextureView`相比`SurfaceView`更加灵活,可以进行任意变形(如旋转、缩放)并且可以透明,但它...

    android 自定义相机,Camera和camera2.TextureView,相机遮罩层demo

    TextureView是一个可以显示OpenGL纹理的视图,它适合用来作为相机预览的显示窗口,相比SurfaceView,TextureView提供了更平滑的图像显示和更好的旋转处理能力。 接下来,我们将按照以下步骤实现自定义相机: 1. **...

    opengl es2.0 -YUV-RGB互转+显示到手机屏幕 DEMO

    7. **屏幕显示**:最终,OpenGL ES会将帧缓冲的内容发送到手机屏幕进行显示。如果你在Android上工作,这通常涉及到SurfaceView或TextureView的使用。 为了实现这个DEMO,你需要具备一定的OpenGL ES编程基础,包括...

    TextureView+Mediaplayer实现本地视频播放

    `TextureView`继承自`View`,它允许开发者在OpenGL渲染的纹理上进行绘制。相比于传统的`SurfaceView`,`TextureView`具有更好的透明度控制和混合效果,可以在布局中更方便地进行位置和大小调整,更适合于视频播放的...

    android3d-demo

    它们都可以用于在屏幕上渲染3D内容,但TextureView提供了更多的灵活性,支持透明度和硬件加速。 5. **CardFlipAnimation**: 这是一种常见于Android应用中的3D翻转效果,模拟卡片翻转,常用于实现类似抽屉或菜单的...

    AndroidDemo.zip

    `AndroidDemo`展示了如何在`Texture2D`和`ByteBuffer`之间进行转换,这对于在GPU上处理图像数据至关重要,比如进行滤镜效果或者实时图像分析。 此外,`byte[]`与`Sprite`的转换是游戏开发中的常见操作。`Sprite`是2...

    Android 预览基于UVC协议的摄像头并截图或录屏 demo

    在预览过程中,可以捕获SurfaceView或TextureView的内容,转换为Bitmap对象,然后保存到本地文件。这通常通过View的drawToBitmap()方法完成,或者利用Surface纹理的OpenGL ES渲染来获取像素数据。 录屏功能则相对...

    android 滤镜处理demo

    Surface是渲染视频帧的目标,而TextureView可以将渲染的视频帧传递到OpenGL ES,这对于应用滤镜非常有用,因为OpenGL ES支持复杂的图形和图像处理。 3. **OpenGL ES**:OpenGL ES(Embedded Systems)是Android上...

    视频播放器 demo

    `TextureView`是Android 4.0(API级别16)引入的一个视图类,它允许在Surface上显示OpenGL纹理。在视频播放中,`TextureView`作为`MediaPlayer`的渲染目标,将视频帧显示到屏幕上。相比旧的`SurfaceView`,`...

    AndroidOpenGLDemo-master:OpenGL 3D开发原始程序圆顶

    说明这是一个Android OpenGLES2.0从零开始的Demo程序,仅做个人学习OpenGLES的记录,并提供给后来初学者参考。若有相关问题,也非常乐意与大家一起讨论共同进步。关于Android OpenGLES2.0学习的博客,也相当于这个...

    CarouselDemo.rar

    这个项目的核心是实现一个3D旋转的滚动视图,类似于我们常见的轮播图或者旋转木马效果,它能以立体的方式展示内容,增加用户界面的交互性和视觉吸引力。 在Android平台上,实现3D旋转的轮播效果通常涉及到以下几个...

    Rajawali入门demo

    这个“Rajawali入门demo”着重展示了如何使用Rajawali库创建交互式和动态的3D场景,具体包括物体的拖拽操作以及根据音乐频谱动态显示音柱的效果。 首先,我们来详细了解一下Rajawali库。Rajawali是基于OpenGL ES...

    Android应用源码之360全景查看demo.zip

    3. **SurfaceView** 或 **TextureView**:在Android中,显示OpenGL ES内容通常需要SurfaceView或TextureView。SurfaceView是一个可以显示硬件加速的图形表面的视图,而TextureView则允许将OpenGL纹理映射到其上。...

    Demo——图片处理

    对于相机拍照或视频截图,可能需要实时预览效果,这涉及到SurfaceView或TextureView的使用,以及Camera API或Camera2 API的掌握。 综上所述,"Demo——图片处理"项目涵盖了Android图片处理的多个重要知识点,从...

    安卓Android源码——书籍翻页效果的demo.zip

    页面的绘制可能涉及到Bitmap的使用,将书页的内容预先加载到位图中,以便在动画中高效地展示。 3. **动画实现**:Android提供了多种动画API,如ValueAnimator、ObjectAnimator以及动画集合类。在这个demo中,开发者...

    CameraMaster:自定义相机+ camera2 + opengles +各种系统相机操作

    一个学习自定义的Camera1,Camera2,Camera X和OpenglES的演示 版本迭代 1.3完善部分bug(暂时停止维护) 1.2添加镜头录像和硬件设备信息调节界面 1.1添加Camera 2相机使用界面 1.0添加Camera 1相机使用界面 感谢 ...

    Android代码-书籍翻页效果的demo.zip

    开发者会创建一个新的View或者继承已有的View类,比如ImageView或TextureView,来绘制页面内容。在自定义的View中,需要重写onDraw()方法,根据当前页面的状态(是正面还是背面,以及翻转的进度)来绘制相应的图像。...

    安卓开发-Android高级图片滚动控件,3D版的图片轮播器Demo.zip

    在这个过程中,需要重写onDraw()方法,用OpenGL ES进行图形绘制,并通过SurfaceView或TextureView来显示。 3. **动画框架**:在Android中,可以使用Animation或Animator类来创建动画效果。对于3D轮播,可能需要用到...

    Android 坦克游戏Demo 工程源码

    【Android坦克游戏Demo工程源码】是一个用于学习和参考的Android开发项目,它展示了如何在Android平台上构建一款基于经典坦克游戏的示例应用。这个源码可以帮助开发者了解Android游戏开发的基本流程,包括游戏逻辑、...

Global site tag (gtag.js) - Google Analytics