Open GL ES-＞无深度测试，获取帧缓冲FBO+颜色附着实现3D立方体图像的截屏Bitmap

原创

已于 2025-04-14 17:31:56 修改 · 396 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#3d #android #android studio #开发语言 #贴图

于 2025-04-11 18:03:55 首次发布

`XML`文件

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

    <com.example.myapplication.EGLSurfaceView
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <ImageView
        android:id="@+id/image"
        android:layout_marginTop="10dp"
        android:layout_marginStart="10dp"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:background="@drawable/ic_launcher_background" />
</FrameLayout>

`Activity`代码

private lateinit var mImage : ImageView
class MainActivity8 : AppCompatActivity() {
   
   
    override fun onCreate(savedInstanceState: Bundle?) {
   
   
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main8)
        mImage = findViewById<ImageView>(R.id.image)
    }
}

`SurfaceView`代码

class EGLSurfaceView(context: Context, attrs: AttributeSet? = null) : SurfaceView(context, attrs) {
   
   
    private val renderer = EGLRenderer(context)

    init {
   
   
        holder.addCallback(renderer.surfaceCallback)
    }

    // 可以提供额外配置方法
    fun setRenderStrategy(strategy: RenderStrategy) {
   
   
        renderer.setRenderStrategy(strategy)
    }
}

渲染器代码

class EGLRenderer(context: Context) {
   
   
    // 外观模式 封装了渲染引擎和渲染策略
    private val strategy: RenderStrategy = MyRenderStrategy(context)
    private val engine: EGLRenderEngine = EGLRenderEngine(strategy)

    // 策略模式 可以提供配置方法
    fun setRenderStrategy(strategy: RenderStrategy) {
   
   
        // 允许用户自定义渲染策略
    }


    // 适配器模式 提供给SurfaceView使用的回调
    val surfaceCallback = object : SurfaceHolder.Callback {
   
   
        override fun surfaceCreated(holder: SurfaceHolder) {
   
   
            engine.onSurfaceCreated(holder.surface)
        }

        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
   
   
            engine.onSurfaceChanged(width, height)
        }

        override fun surfaceDestroyed(holder: SurfaceHolder) {
   
   
            engine.onSurfaceDestroyed()
        }
    }
}

渲染引擎代码

class EGLRenderEngine(private val strategy: RenderStrategy) {
   
   
    private var mEGLEnvironment: EGLEnvironment? = null
    private var mRenderThread: RenderThread? = null

    fun onSurfaceCreated(surface: Surface) {
   
   
        mRenderThread = RenderThread(surface, strategy).apply {
   
   
            start()
        }
    }

    fun onSurfaceChanged(width: Int, height: Int) {
   
   
        mRenderThread?.updateSize(width, height)
    }

    fun onSurfaceDestroyed() {
   
   
        mRenderThread?.shutdown()
        mRenderThread = null
    }

    private inner class RenderThread(
        private val surface: Surface,
        private val strategy: RenderStrategy
    ) : Thread() {
   
   
        @Volatile private var running = true
        @Volatile private var sizeChanged = false
        private var width = 0
        private var height = 0

        fun updateSize(width: Int, height: Int) {
   
   
            this.width = width
            this.height = height
            sizeChanged = true
        }

        fun shutdown() {
   
   
            running = false
            interrupt()
            strategy.onSurfaceDestroyed()
            mEGLEnvironment?.release()
        }

        override fun run() {
   
   
            try {
   
   
                // 使用构建者创建EGL环境
                mEGLEnvironment = EGLEnvironmentBuilder().build(surface)

                // 初始化渲染策略
                strategy.onSurfaceCreated()

                // 渲染循环
                while (running) {
   
   
                    if (sizeChanged) {
   
   
                        strategy.onSurfaceChanged(width, height)
                        sizeChanged = false
                    }

                    strategy.onDrawFrame()
                    mEGLEnvironment?.swapBuffers()

                }
            } catch (e: Exception) {
   
   
                Log.e("RenderEngine", "Render thread error: ${
     
     e.message}")
            }
        }
    }
}

自定义渲染策略代码

// 策略模式：定义不同的渲染策略
interface RenderStrategy {
   
   
    fun onSurfaceCreated()
    fun onSurfaceChanged(width: Int, height: Int)
    fun onDrawFrame()
    fun onSurfaceDestroyed()
}

// 可以提供多种渲染策略实现
class MyRenderStrategy(private val context: Context) : RenderStrategy {
   
   
    var mDrawData: MyDrawData2? = null

    // 实现代码与前面相同
    override fun onSurfaceCreated() {
   
   
        GLES30.glClearColor(0.0f, 0.5f, 0.5f, 1.0f)
        mDrawData = MyDrawData2().apply {
   
   
            initTexture0(context, R.drawable.picture)
            initShaderProgram()
            initVertexBuffer()
        }
    }

    override fun onSurfaceChanged(width: Int, height: Int) {
   
   
        GLES30.glViewport(0, 0, width, height)
        mDrawData?.setSurfaceSize(width, height)
    }

    override fun onDrawFrame() {
   
   
        GLES30.glEnable(GLES30.GL_DEPTH_TEST)
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT or GLES30.GL_DEPTH_BUFFER_BIT)
        mDrawData?.drawCurrentOutput()
    }

    override fun onSurfaceDestroyed() {
   
   
        mDrawData?.release()
    }
}

搭建`EGL`环境代码

// 构建者模式：配置和构建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