Open GL ES-＞EGL渲染环境、数据、引擎、线程的创建

最新推荐文章于 2025-12-19 20:15:38 发布
原创 最新推荐文章于 2025-12-19 20:15:38 发布 · 224 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #android #android studio #开发语言 #kotlin

EGL环境

抽象工厂模式定义EGL环境接口

interface EGLComponentFactory {
    fun createEGL(): EGL10
    fun createEGLDisplay(egl: EGL10): EGLDisplay
    fun createEGLConfig(egl: EGL10, display: EGLDisplay): EGLConfig
    fun createEGLContext(egl: EGL10, display: EGLDisplay, config: EGLConfig): EGLContext
    fun createEGLSurface(
        egl: EGL10,
        display: EGLDisplay,
        config: EGLConfig,
        surface: Surface
    ): EGLSurface
}

EGL环境接口的具体实现


class DefaultEGLFactory : EGLComponentFactory {
    override fun createEGL(): EGL10 = EGLContext.getEGL() as EGL10

    override fun createEGLDisplay(egl: EGL10): EGLDisplay {
        val eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY)
        if (eglDisplay == EGL10.EGL_NO_DISPLAY) {
            throw RuntimeException("eglGetDisplay failed")
        }

        val version = IntArray(2)
        if (!egl.eglInitialize(eglDisplay, version)) {
            throw RuntimeException("eglInitialize failed")
        }
        return eglDisplay
    }

    override fun createEGLConfig(egl: EGL10, display: EGLDisplay): EGLConfig {
        val attributes = intArrayOf(
            EGL_RED_SIZE, 8,
            EGL_GREEN_SIZE, 8,
            EGL_BLUE_SIZE, 8,
            EGL_ALPHA_SIZE, 8,
            EGL_DEPTH_SIZE, 8,
            EGL_STENCIL_SIZE, 8,
            EGL_NONE
        )

        val numConfigs = IntArray(1)
        egl.eglChooseConfig(display, attributes, null, 0, numConfigs)

        if (numConfigs[0] <= 0) {
            throw RuntimeException("No matching EGL configs")
        }

        val configs = arrayOfNulls<EGLConfig>(numConfigs[0])
        egl.eglChooseConfig(display, attributes, configs, numConfigs.size, numConfigs)

        return configs[0] ?: throw RuntimeException("No suitable EGL config found")
    }

    override fun createEGLContext(egl: EGL10, display: EGLDisplay, config: EGLConfig): EGLContext {
        val contextAttrs = intArrayOf(
            EGL_CONTEXT_CLIENT_VERSION, 3,
            EGL_NONE
        )
        val eglContext = egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, contextAttrs)
        if (eglContext == EGL10.EGL_NO_CONTEXT) {
            throw RuntimeException("eglCreateContext failed")
        }
        return eglContext
    }

    override fun createEGLSurface(
        egl: EGL10,
        display: EGLDisplay,
        config: EGLConfig,
        surface: Surface
    ): EGLSurface {
        val eglSurface = egl.eglCreateWindowSurface(display, config, surface, null)
        if (eglSurface == EGL10.EGL_NO_SURFACE) {
            throw RuntimeException("eglCreateWindowSurface failed")
        }
        return eglSurface
    }
}

构造者实现EGL环境

class EGLEnvironmentBuilder(private val factory: EGLComponentFactory = DefaultEGLFactory()) {
    private lateinit var mEGL: EGL10
    private lateinit var mEGLDisplay: EGLDisplay
    private lateinit var mEGLConfig: EGLConfig
    private lateinit var mEGLContext: EGLContext
    private lateinit var mEGLSurface: EGLSurface

    fun build(surface: Surface): EGLEnvironment {
        mEGL = factory.createEGL()
        mEGLDisplay = factory.createEGLDisplay(mEGL)
        mEGLConfig = factory.createEGLConfig(mEGL, mEGLDisplay)
        mEGLContext = factory.createEGLContext(mEGL, mEGLDisplay, mEGLConfig)
        mEGLSurface = factory.createEGLSurface(mEGL, mEGLDisplay, mEGLConfig, surface)

        if (!mEGL.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
            throw RuntimeException("eglMakeCurrent failed")
        }

        return EGLEnvironment(mEGL, mEGLDisplay, mEGLContext, mEGLSurface)
    }

    // EGL环境类
    inner class EGLEnvironment(
        val egl: EGL10,
        val display: EGLDisplay,
        val context: EGLContext,
        val surface: EGLSurface
    ) {

        fun swapBuffers() {
            if (!egl.eglSwapBuffers(display, surface)) {
                throw RuntimeException("eglSwapBuffers failed")
            }
        }

        fun release() {
            egl.eglMakeCurrent(
                display,
                EGL10.EGL_NO_SURFACE,
                EGL10.EGL_NO_SURFACE,
                EGL10.EGL_NO_CONTEXT
            )
            egl.eglDestroySurface(display, surface)
            egl.eglDestroyContext(display, context)
            egl.eglTerminate(display)
        }
    }
}

渲染数据

渲染数据接口定义

/**
 * OpenGL渲染数据接口
 */
interface OpenGLData  {
    /**
     * Surface创建时调用，用于初始化OpenGL资源
     */
    fun onSurfaceCreated()

    /**
     * Surface尺寸变化时调用，用于更新视口
     */
    fun onSurfaceChanged(width: Int, height: Int)

    /**
     * 每帧渲染时调用，执行实际的绘制操作
     */
    fun onDrawFrame()

    /**
     * Surface销毁时调用，可以标记资源需要重新初始化
     */
    fun onSurfaceDestroyed()
}

渲染数据接口实现

/**
 * OpenGL渲染数据默认实现类
 * 提供OpenGL渲染所需的基本数据结构和操作方法
 */
class BaseOpenGLData(private val context: Context) : OpenGLData {

    private val NO_OFFSET = 0
    private val VERTEX_POS_DATA_SIZE = 3
    private val TEXTURE_POS_DATA_SIZE = 2
    private val STRIDE = (VERTEX_POS_DATA_SIZE + TEXTURE_POS_DATA_SIZE) * 4 // 每个顶点的总字节数

    // 着色器程序ID
    private var mProgram: Int = -1

    // 顶点和纹理坐标合并在一个数组中
    // 格式：x, y, z, u, v (顶点坐标后跟纹理坐标)
    val vertexData = floatArrayOf(
        // 顶点坐标            // 纹理坐标
        -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // 左上
        -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, // 左下
        1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // 右上
        1.0f, -1.0f, 0.0f, 1.0f, 0.0f  // 右下
    )

    val vertexDataBuffer = ByteBuffer.allocateDirect(vertexData.size * 4)
        .order(ByteOrder.nativeOrder())
        .asFloatBuffer()
        .put(vertexData)
        .position(NO_OFFSET)

    val index = shortArrayOf(
        0, 1, 2, // 第一个三角形
        1, 3, 2  // 第二个三角形
    )

    val indexBuffer = ByteBuffer.allocateDirect(index.size * 2)
        .order(ByteOrder.nativeOrder())
        .asShortBuffer()
        .put(index)
        .position(NO_OFFSET)

    // VAO(Vertex Array Object), 顶点数组对象, 用于存储VBO
    private var mVAO = IntArray(1)

    // VBO(Vertex Buffer Object), 顶点缓冲对象，用于存储顶点数据和纹理数据
    private var mVBO = IntArray(1) // 只需要一个VBO

    // IBO(Index Buffer Object), 索引缓冲对象，用于存储顶点索引数据
    private var mIBO = IntArray(1)

    // 纹理ID
    private var mTextureID = IntArray(1)

    // 变换矩阵
    private var mMVPMatrix = FloatArray(16)      // 最终变换矩阵
    private val mProjectionMatrix = FloatArray(16)  // 投影矩阵
    private val mViewMatrix = FloatArray(16)       // 视图矩阵
    private val mModelMatrix = FloatArray(16)      // 模型矩阵

    // 视口尺寸
    private var mWidth = 0
    private var mHeight = 0

    /**
     * Surface创建时调用，用于初始化OpenGL资源
     */
    override fun onSurfaceCreated() {
        initTexture()
        initShaderProgram()
        initVertexBuffer()
        resetMatrix()
    }

    /**
     * Surface尺寸变化时调用，用于更新视口
     */
    override fun onSurfaceChanged(width: Int, height: Int) {
        GLES30.glViewport(0, 0, width, height)
        mWidth = width
        mHeight = height
        computeMVPMatrix()
    }

    /**
     * 每帧渲染时调用，执行实际的绘制操作
     */
    override fun onDrawFrame() {
        clearBuffers()
        draw()
    }

    /**
     * Surface销毁时调用，可以标记资源需要重新初始化
     */
    override fun onSurfaceDestroyed() {
        release()
    }

    /**
     * 初始化着色器程序
     */
    private fun initShaderProgram() {
        val vertexShaderCode = """#version 300 es
            uniform mat4 uMVPMatrix; // 变换矩阵
            in vec4 aPosition; // 顶点坐标
            in vec2 aTexCoord; // 纹理坐标 
            out vec2 vTexCoord; 
            void main() {
                // 输出顶点坐标和纹理坐标到片段着色器
                gl_Position = uMVPMatrix * aPosition;
                vTexCoord = aTexCoord;
            }""".trimIndent()
        val fragmentShaderCode = """#version 300 es
         precision mediump float;
         uniform sampler2D uTexture_0;
         in vec2 vTexCoord;
         out vec4 fragColor;
         void main() {
             fragColor = texture(uTexture_0, vTexCoord);
         }""".trimIndent()

        // 加载顶点着色器和片段着色器, 并创建着色器程序
        val vertexShader = OpenGLUtils.loadShader(GLES30.GL_VERTEX_SHADER, vertexShaderCode)
        val fragmentShader = OpenGLUtils.loadShader(GLES30.GL_FRAGMENT_SHADER, fragmentShaderCode)
        mProgram = GLES30.glCreateProgram()
        GLES30.glAttachShader(mProgram, vertexShader)
        GLES30.glAttachShader(mProgram, fragmentShader)
        GLES30.glLinkProgram(mProgram)

        // 删除着色器对象
        GLES30.glDeleteShader(vertexShader)
        GLES30.glDeleteShader(fragmentShader)
    }

    /**
     * 初始化顶点缓冲区
     */
    private fun initVertexBuffer() {
        // 绑定VAO
        GLES30.glGenVertexArrays(mVAO.size, mVAO, NO_OFFSET)
        GLES30.glBindVertexArray(mVAO[0])

        // 绑定VBO - 只需要一个VBO存储所有数据
        GLES30.glGenBuffers(mVBO.size, mVBO, NO_OFFSET)
        GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, mVBO[0])
        GLES30.glBufferData(
            GLES30.GL_ARRAY_BUFFER,
            vertexData.size * 4,
            vertexDataBuffer,
            GLES30.GL_STATIC_DRAW
        )

        // 设置顶点属性指针 - 顶点坐标
        val positionHandle = GLES30.glGetAttribLocation(mProgram, "aPosition")
        GLES30.glEnableVertexAttribArray(positionHandle)
        GLES30.glVertexAttribPointer(
            positionHandle,
            VERTEX_POS_DATA_SIZE,
            GLES30.GL_FLOAT,
            false,
            STRIDE,     // 步长，每个顶点5个float (x,y,z,u,v)
            NO_OFFSET   // 偏移量，位置数据在前
        )

        // 设置顶点属性指针 - 纹理坐标
        val textureHandle = GLES30.glGetAttribLocation(mProgram, "aTexCoord")
        GLES30.glEnableVertexAttribArray(textureHandle)
        GLES30.glVertexAttribPointer(
            textureHandle,
            TEXTURE_POS_DATA_SIZE,
            GLES30.GL_FLOAT,
            false,
            STRIDE,                          // 步长，每个顶点5个float (x,y,z,u,v)
            VERTEX_POS_DATA_SIZE * 4         // 偏移量，纹理数据在位置数据之后
        )

        // 绑定IBO
        GLES30.glGenBuffers(mIBO.size, mIBO, NO_OFFSET)
        // 绑定索引缓冲区数据到IBO[0]
        GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER, mIBO[0])
        GLES30.glBufferData(
            GLES30.GL_ELEMENT_ARRAY_BUFFER,
            index.size * 2,
            indexBuffer,
            GLES30.GL_STATIC_DRAW
        )

        // 解绑VAO
        GLES30.glBindVertexArray(0)
        // 解绑VBO和IBO
        GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0)
        GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER, 0)
    }

    /**
     * 初始化纹理
     */
    private fun initTexture() {
        val textureId = IntArray(1)
        // 生成纹理
        GLES30.glGenTextures(1, textureId, 0)
        // 绑定纹理
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId[0])
        // 设置纹理参数
        GLES30.glTexParameteri(
            GLES30.GL_TEXTURE_2D,
            GLES30.GL_TEXTURE_MIN_FILTER,
            GLES30.GL_LINEAR
        ) // 纹理缩小时使用线性插值
        GLES30.glTexParameteri(
            GLES30.GL_TEXTURE_2D,
            GLES30.GL_TEXTURE_MAG_FILTER,
            GLES30.GL_LINEAR
        ) // 纹理放大时使用线性插值
        GLES30.glTexParameteri(
            GLES30.GL_TEXTURE_2D,
            GLES30.GL_TEXTURE_WRAP_S,
            GLES30.GL_CLAMP_TO_EDGE
        ) // 纹理坐标超出范围时，超出部分使用最边缘像素进行填充
        GLES30.glTexParameteri(
            GLES30.GL_TEXTURE_2D,
            GLES30.GL_TEXTURE_WRAP_T,
            GLES30.GL_CLAMP_TO_EDGE
        ) // 纹理坐标超出范围时，超出部分使用最边缘像素进行填充
        // 加载图片
        val options = BitmapFactory.Options().apply {
            inScaled = false // 不进行缩放
        }
        val bitmap = BitmapFactory.decodeResource(context.resources, R.drawable.picture, options)
        // 将图片数据加载到纹理中
        GLUtils.texImage2D(GLES30.GL_TEXTURE_2D, 0, bitmap, 0)
        // 释放资源
        bitmap.recycle()
        // 解绑纹理
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0)
        Log.e(
            "yang",
            "loadTexture: 纹理加载成功 bitmap.width:${bitmap.width} bitmap.height:${bitmap.height}"
        )
        mTextureID[0] = textureId[0]
    }


    /**
     * 重置矩阵
     */
    private fun resetMatrix() {
        Matrix.setIdentityM(mProjectionMatrix, NO_OFFSET)
        Matrix.setIdentityM(mViewMatrix, NO_OFFSET)
        Matrix.setIdentityM(mModelMatrix, NO_OFFSET)
        Matrix.setIdentityM(mMVPMatrix, NO_OFFSET)
    }

    /**
     * 计算最终变换矩阵
     */
    private fun computeMVPMatrix() {
        val isLandscape = mWidth > mHeight
        val viewPortRatio = if (isLandscape) mWidth.toFloat() / mHeight else mHeight.toFloat() / mWidth

        // 计算包围图片的球半径
        val radius = sqrt(1f + viewPortRatio * viewPortRatio)
        val near = 0.1f
        val far = near + 2 * radius
        val distance = near / (near + radius)

        // 视图矩阵View Matrix
        Matrix.setLookAtM(
            mViewMatrix, NO_OFFSET,
            0f, 0f, near + radius,  // 相机位置
            0f, 0f, 0f,             // 看向原点
            0f, 1f, 0f              // 上方向
        )

        // 投影矩阵Projection Matrix
        Matrix.frustumM(
            mProjectionMatrix, NO_OFFSET,
            if (isLandscape) (-viewPortRatio * distance) else (-1f * distance),  // 左边界
            if (isLandscape) (viewPortRatio * distance) else (1f * distance),    // 右边界
            if (isLandscape) (-1f * distance) else (-viewPortRatio  * distance),  // 下边界
            if (isLandscape) (1f * distance) else (viewPortRatio * distance),    // 上边界
            near, // 近平面
            far // 远平面
        )

        // 最终变换矩阵，第一次变换，模型矩阵 x 视图矩阵 = Model x View, 但是OpenGL ES矩阵乘法是右乘，所以是View x Model
        Matrix.multiplyMM(
            mMVPMatrix,
            NO_OFFSET,
            mViewMatrix,
            NO_OFFSET,
            mModelMatrix,
            NO_OFFSET
        )

        // 最终变换矩阵，第二次变换，模型矩阵 x 视图矩阵 x 投影矩阵 = Model x View x Projection, 但是OpenGL ES矩阵乘法是右乘，所以是Projection x View x Model
        Matrix.multiplyMM(
            mMVPMatrix,
            NO_OFFSET,
            mProjectionMatrix,
            NO_OFFSET,
            mMVPMatrix,
            NO_OFFSET
        )

        // 纹理坐标系为(0, 0), (1, 0), (1, 1), (0, 1)的正方形逆时针坐标系，从Bitmap生成纹理，即像素拷贝到纹理坐标系
        // 变换矩阵需要加上一个y方向的翻转, x方向和z方向不改变
        Matrix.scaleM(
            mMVPMatrix,
            NO_OFFSET,
            1f,
            -1f,
            1f,
        )
    }

    /**
     * 清除缓冲区
     */
    private fun clearBuffers() {
        // 清除颜色缓冲区
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT)
    }

    /**
     * 绘制图形
     */
    private fun draw() {
        val state = saveGLState()
        try {
            GLES30.glUseProgram(mProgram)
            enableTexture0(mProgram, mTextureID[0])
            // 解析变换矩阵
            val matrixHandle = GLES30.glGetUniformLocation(mProgram, "uMVPMatrix")
            GLES30.glUniformMatrix4fv(matrixHandle, 1, false, mMVPMatrix, NO_OFFSET)

            // 绑定VAO
            GLES30.glBindVertexArray(mVAO[0])
            // 绘制图形
            GLES30.glDrawElements(
                GLES30.GL_TRIANGLES,
                index.size,
                GLES30.GL_UNSIGNED_SHORT,
                NO_OFFSET
            )
            // 解绑VAO
            GLES30.glBindVertexArray(0)
            disableTexture0()
        } finally {
            restoreGLState(state)
        }
    }

    /**
     * 释放资源
     */
    private fun release() {
        // 删除着色器程序、VAO、VBO和纹理等OpenGL资源
    }
}


object OpenGLUtils {

    // OpenGL状态数据类
    data class GLState(
        val viewport: IntArray,
        val program: Int,
        val framebuffer: Int
    )

    // 保存OpenGL状态
    fun saveGLState(): GLState {
        val viewport = IntArray(4)
        val program = IntArray(1)
        val framebuffer = IntArray(1)
        GLES30.glGetIntegerv(GLES30.GL_VIEWPORT, viewport, 0)
        GLES30.glGetIntegerv(GLES30.GL_CURRENT_PROGRAM, program, 0)
        GLES30.glGetIntegerv(GLES30.GL_FRAMEBUFFER_BINDING, framebuffer, 0)
        return GLState(viewport, program[0], framebuffer[0])
    }

    // 恢复OpenGL状态
    fun restoreGLState(state: GLState) {
        GLES30.glViewport(
            state.viewport[0],
            state.viewport[1],
            state.viewport[2],
            state.viewport[3]
        )
        GLES30.glUseProgram(state.program)
        GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, state.framebuffer)
    }

    fun enableTexture0(program: Int, id: Int) {
        GLES30.glActiveTexture(GLES30.GL_TEXTURE0)
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, id)
        val textureSampleHandle = GLES30.glGetUniformLocation(program, "uTexture_0")
        if (textureSampleHandle != -1) {
            GLES30.glUniform1i(textureSampleHandle, 0)
        }
    }

    fun disableTexture0() {
        GLES30.glActiveTexture(GLES30.GL_TEXTURE0)
        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0)
    }

    // 创建着色器对象
    fun loadShader(type: Int, source: String): Int {
        val shader = GLES30.glCreateShader(type)
        GLES30.glShaderSource(shader, source)
        GLES30.glCompileShader(shader)
        return shader
    }
}

渲染引擎

渲染引擎接口

/**
 * OpenGL渲染引擎接口
 */
interface OpenGLEngine  {
    /**
     * SurfaceHolder回调，用于绑定到SurfaceView
     */
    val callback: SurfaceHolder.Callback

    /**
     * 请求执行一次渲染
     */
    fun requestRender(mode : Int? = null)
}

渲染引擎接口实现

open class BaseOpenGLEngine(private val renderData: OpenGLData) : OpenGLEngine {
    private var mRenderThread: RenderThread? = null

    override val callback: SurfaceHolder.Callback = object : SurfaceHolder.Callback {
        override fun surfaceCreated(holder: SurfaceHolder) {
            mRenderThread = RenderThread(holder.surface, renderData)?.apply {
                start()
            }
        }

        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
            mRenderThread?.updateSize(width, height)
        }

        override fun surfaceDestroyed(holder: SurfaceHolder) {
            mRenderThread?.shutdown()
            mRenderThread = null
        }
    }

    override fun requestRender(mode: Int?) {
        mRenderThread?.requestRender(mode)
    }
}

渲染线程

class RenderThread(private val surface: Surface, private val renderData: OpenGLData) : Thread() {
    private val TAG = "RenderThread"

    private var mEGLEnvironment : EGLEnvironmentBuilder.EGLEnvironment ?= null

    @Volatile
    private var running = true

    @Volatile
    private var sizeChanged = false

    @Volatile
    private var renderMode = RENDERMODE_WHEN_DIRTY

    @Volatile
    private var requestRender = true
    private var mCacheWidth = 0
    private var mCacheHeight = 0
    private val lock = Object()

    fun updateSize(width: Int, height: Int) {
        synchronized(lock) {
            mCacheWidth = width
            mCacheHeight = height
            sizeChanged = true
            requestRender = true
            lock.notifyAll()
            Log.d(TAG, "updateSize width = $width, height = $height")
        }
    }

    fun requestRender(mode: Int? = null) {
        synchronized(lock) {
            mode?.let { renderMode = it }
            requestRender = true
            lock.notifyAll()
            Log.d(TAG, "requestRender${mode?.let { " mode = $it" } ?: ""}")
        }
    }

    fun shutdown() {
        synchronized(lock) {
            running = false
            lock.notifyAll()
            Log.d(TAG, "requestRender shutdown")
        }
        join() // 等待线程完成

        renderData.onSurfaceDestroyed()
        mEGLEnvironment?.release()
    }

    override fun run() {
        mEGLEnvironment = EGLEnvironmentBuilder().build(surface)
        renderData.onSurfaceCreated()
        renderLoop()
    }

    private fun renderLoop() {
        while (running) {
            synchronized(lock) {
                // 等待渲染条件
                while (running && !requestRender && !sizeChanged && renderMode != RENDERMODE_CONTINUOUSLY) {
                    lock.wait()
                }

                if (!running) return

                // 处理尺寸变化
                if (sizeChanged) {
                    renderData.onSurfaceChanged(mCacheWidth, mCacheHeight)
                    sizeChanged = false
                }

                // 处理渲染
                if (requestRender || renderMode == RENDERMODE_CONTINUOUSLY) {
                    renderData.onDrawFrame()
                    mEGLEnvironment?.swapBuffers()
                    requestRender = false
                }
            }
        }
    }
}

activity_main的XML文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <!-- 预览区Fragment容器 -->
    <FrameLayout
        android:id="@id/preview_fragment_container"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#000000">
        <com.example.render.opengl.BaseSurfaceView
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    </FrameLayout>

    <!-- 操作区Fragment容器 -->
    <FrameLayout
        android:id="@+id/operate_fragment_container"
        android:layout_width="match_parent"
        android:layout_height="230dp"
        android:background="#F5F5F5" />
</LinearLayout>

Activity的代码

class MainActivity : AppCompatActivity() {\
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

效果图

在这里插入图片描述

OpenGL ES 共享上下文实现多线程渲染
字节流动
11-13 1万+
OpenGL ES 共享上下文时，可以共享哪些资源？共享上下文实现多线程渲染EGL 概念回顾查询绘图表面的可用类型和配置；，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。本地窗口相关的 API 提供了访问本地窗口系统的接口，而 E，接下来 OpenGL ES 就可以在这个渲染表面上绘制。egl、opengles 和设备之间的关系图片中：Display (EGLDisplay) 是对实际显示设备的抽象；
Camera Api 2 和 OPEN GL ES 使用（显示滤镜效果）
LiggerBill的博客
06-24 1279
相机预览滤镜功能实现，通过cameraAPI2 配合 OpenGL ES简单实现效果。 主要在于继承GLSurfaceView 和实现 GLSurfaceView.Renderer，同时将创建的surface 传递到相机中。后续相机图像传入onDrawFrame中，并在通过Opengl 提供的方法，在gl线程中渲染预览图像，达到显示效果。
Open GL ES -＞ SurfaceView + 自定义EGL实现OpenGL渲染框架
sunshine_guo的博客
04-08 520
Open GL ES -> SurfaceView + 自定义EGL实现OpenGL渲染框架的Kotlin代码
android 多线程创建texture,从源码角度剖析Android系统EGL及GL线程
weixin_30953203的博客
05-25 917
本文转载自天天P图攻城狮微信公众号，作者：天天P图Android工程师kenneyqin(覃华峥)，原文链接https://mp.weixin.qq.com/s/j_N5_C7iQUPWENdRYfjdxg。未经过作者同意请勿擅自转载。从事OpenGL ES相关开发的技术人员，常常会对一些问题感到困惑，例如GL线程究竟是什么？为什么在这个GL线程申请的texture不能在另外一个GL线程使用？如何...
3.OpenglES——EGL环境的创建
liuyizhou95的博客
04-26 4075
参考：Android EGL Android EGL接口解析 khronos官方文档 OpenGL ES 深入 OpenGLES - EGL环境搭建 书写本文的初衷是为了自我学习 何为EGL？ 首先Android官方的解释： OpenGL ES 定义了一个渲染图形的 API，但没有定义窗口系统。为了让 GLES 能够适合各种平台，GLES 将与知道如何通过操作系统创建和访问窗口的库结合使用。用于...
Android OpenGLES开发：EGL环境搭建
xiaozhiwz的专栏
09-04 2932
本文简述了OpenGL是如何将绘制的图像显示到设备上的，这离不开EGL的功劳
Android-音视频学习系列-(六)掌握视频基础知识并使用-OpenGL-ES-2-0-渲染-YUV-数据
2401_84544434的博客
04-29 1138
OpenGL(Open Graphics Lib) 定义了一个跨编程语言、跨平台编程的专业图形程序接口。可用于二维或三维图像的处理与渲染，它是一个功能强大、调用方便的底层图形库。对于嵌入式的设备，其提供了OpenGL ES(OpenGL for Embedded System) 版本，该版本是针对手机、Pad 等嵌入式设备而设计的，是 OpenGL 的一个子集。到目前为止，OpenGL ES 已经经历过很多版本的迭代与更新，到目前为止运用最广泛的还是OpenGL ES2.0 版本。
Unity 渲染YUV数据 ---- 以Unity渲染Android Camera数据为例子
newchenxf的专栏
09-30 4003
Unity渲染Android的Camera YUV 裸数据，在shader中做YUV->RGB转换
android渲染是skia与egl,Android 重学系列 SurfaceView和TextureView 源码浅析(下)
weixin_36086032的博客
05-30 1805
前言上一篇文章和大家论述了SurfaceView的核心原理，本文和大家聊聊TextureView的核心原理。正文TextureView的用法这里稍微解释一下。用一个官方的demo看看。public class LiveCameraActivity extends Activity implements TextureView.SurfaceTextureListener {private Came...
精选资源
Android平台OpenGLES3将GL-TEXTURE-2D纹理id渲染到ImageReader提供的Surface上
06-28
3、在EGL线程中，渲染GL_TEXTURE_2D对应的纹理图形； 4、在EGL线程中，完成渲染后，通过eglSwapBuffers方法交换缓冲数据； 5、在ImageReader中onImageAvailable方法中读取surface数据，保存为一张Bitmap； 6、将 ...
车载系统应用开发集成系统API
yangyulong0622的博客
12-16 245
车载开发中，为了快速迭代常将系统应用剥离为普通应用开发，但调用系统API时反射效率低。解决方法是通过集成framework.jar，但会遇到编译报错问题。通用方案是在gradle中配置bootstrapClasspath引入jar包。当使用高版本JDK时，必须强制指定模块使用JDK8并关闭lint检查才能生效。关键步骤：先加载jar包到工程，再设置模块JDK版本为1.8。
命令执行漏洞 (RCE) 渗透测试实战指南
weixin_45631123的博客
12-15 343
Burp Suite 或 OWASP ZAP 抓包工具、授权测试环境。：Burp Collaborator 或公网DNS服务器。：Java Web应用，可注入Java代码。：安装ysoserial工具、Java环境。：安装Commix、Python3环境。：识别表单输入点（如登录框）：无回显但命令执行成功时。：确认RCE漏洞存在。
JAVA设计模式之观察者模式
pingguocu3的博客
12-17 313
在我们开发的过程中，经常会遇到一些当什么什么事情发生的时候，然后做什么什么事。比如某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。著作权归作者所有,转载或内容合作请联系作者。
使用idea启动一个springboot项目
qq_51389137的博客
12-19 441
5.装配置maven配置到idea下载项目依赖。4.装navicat。
LinkedHashMap：有序HashMap
weixin_43076660的博客
12-15 797
LinkedHashMap是HashMap的子类，通过双向链表维护元素顺序，支持插入顺序和访问顺序两种模式。其核心结构是哈希表+双向链表，节点类扩展了前驱和后继指针。默认按插入顺序维护链表，设置accessOrder=true可改为访问顺序，适合实现LRU缓存。重写removeEldestEntry方法可自动移除最老元素，get/put操作会触发链表调整。LinkedHashMap通过回调方法（afterNodeAccess/Insertion/Removal）在哈希表操作时同步维护链表顺序，既保留Hash
【FastAPI】FastAPI依赖注入完全指南
weixin_63434398的博客
12-18 2159
本文全面介绍FastAPI的依赖注入机制，主要包含两大注入方式：原生自动注入和Depends自定义注入。原生注入支持Request/Response等框架对象以及路径/查询参数等自动解析，而Depends则用于自定义依赖项注入。文章详细讲解依赖注入的核心思想、实现方式、生命周期管理、高级技巧，并通过完整认证系统案例展示实战应用。最后剖析Depends底层原理，并与Spring框架进行对比，帮助开发者彻底掌握FastAPI这一核心特性，实现代码解耦和高效开发。
nl2sql技术实现自动sql生成之Spring AI Alibaba Nl2sql
疾风sxp的博客
12-15 967
上一节我们在介绍了自然语言转sql的基本思路，今天我们通过实操来解决这一技术实现，通过Spring AI Alibaba开源的nl2sql框架进行这块技术的讲解。
JVM性能检测及调优
2403_87639585的博客
12-14 970
JVM 性能调优的核心是 “数据驱动、目标导向”：先通过工具定位瓶颈（内存 / GC / 线程 / CPU），再针对性优化（代码 > 参数），最后验证效果。日常运维中，通过 Prometheus+Grafana 常态化监控，提前发现异常，避免线上故障。对于大多数业务场景，选择 G1GC 并配置合理的堆大小、STW 目标，即可满足需求；超大内存 / 低延迟场景可升级为 ZGC/Shenandoah。
Maven进阶
最新发布
Gu_yyqx的博客
12-19 77
build><resource><includes><excludes><resource><includes>-- 属性替换配置 --><filters></filters>-- 测试资源 --></build>
OPEN_GL ES
04-19
<think>好的，我现在需要帮助用户解决在Android Native层使用OpenGL ES的问题。用户已经提供了之前的回答和一些引用，我需要整合这些信息，并结合我的知识来给出详细的指南和解决方案。 首先，用户的需求是了解在...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值