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

private class SimpleEGLConfigChooser extends ComponentSizeChooser {
     public SimpleEGLConfigChooser(boolean withDepthBuffer) {
         super(8, 8, 8, 0, withDepthBuffer ? 16 : 0, 0);
     }
}

// 设置默认EGLConfig的深度缓冲，true则为16位的深度缓冲
setEGLConfigChooser(boolean needDepth)
// 指定自定义的EGLConfigChooser
setEGLConfigChooser(android.opengl.GLSurfaceView.EGLConfigChooser configChooser)
// 指定各个分量的值
public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,
             int alphaSize, int depthSize, int stencilSize)

// 设置渲染器
public void setRenderer(Renderer renderer)
// 设置渲染模式，仅在setRenderer之后调用生效
public void setRenderMode(int renderMode)

// DEBUG_CHECK_GL_ERROR：每次GL调用都会检查，如果出现glError则会抛出异常
// DEBUG_LOG_GL_CALLS：以TAG为GLSurfaceView将日志记录在verbose级别的日志中
setDebugFlags(int debugFlags)
// 用于调试跟踪代码，可自定义GLWrapper包装GL接口并返回GL接口，可在
setGLWrapper(android.opengl.GLSurfaceView.GLWrapper glWrapper)

// 给GLSurfaceView设置渲染器对象Renderer
public void setRenderer(Renderer renderer)
// 设置渲染模式，仅在setRenderer之后调用生效
public void setRenderMode(int renderMode)

public class GLES20Renderer implements Renderer {
     private static final String TAG = GLES20Renderer.class.getSimpleName();
     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
         Log.i(TAG, "onSurfaceCreated");
         GLES20.glClearColor(0.0f, 0.0f, 1.0f, 1);
     }
     public void onSurfaceChanged(GL10 gl, int width, int height) {
         Log.i(TAG, "onSurfaceChanged");
         GLES20.glViewport(0, 0, width, height);
     }
     public void onDrawFrame(GL10 gl) {
         Log.i(TAG, "onDrawFrame");
         GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
     }
}

// Triangle
class Triangle(context: Context) {
     companion object {
         // 坐标数组中每个顶点的坐标数
         private const val COORDINATE_PER_VERTEX = 3
     }
     private var programHandle: Int = 0
     private var positionHandle: Int = 0
     private var colorHandler: Int = 0
     private var vPMatrixHandle: Int = 0
     private var vertexStride = COORDINATE_PER_VERTEX * 4
     // 三角形的三条边
     private var triangleCoordinate = floatArrayOf( // 逆时针的顺序的三条边
         0.0f, 0.5f, 0.0f, // top
         -0.5f, -0.5f, 0.0f, // bottom left
         0.5f, -0.5f, 0.0f // bottom right
     )
     // 颜色数组
     private val color = floatArrayOf(0.63671875f, 0.76953125f, 0.22265625f, 1.0f)
     private var vertexBuffer: FloatBuffer =
         // (number of coordinate values * 4 bytes per float)
         ByteBuffer.allocateDirect(triangleCoordinate.size * 4).run {
             // ByteBuffer使用本机字节序
             this.order(ByteOrder.nativeOrder())
             // ByteBuffer to FloatBuffer
             this.asFloatBuffer().apply {
                 put(triangleCoordinate)
                 position(0)
             }
         }
     init {
         // read shader sourceCode
         val vertexShaderCode = GLUtil.readShaderSourceCodeFromRaw(context, R.raw.vertex_shader_triangle_default)
         val fragmentShaderCode =
             GLUtil.readShaderSourceCodeFromRaw(context, R.raw.fragment_shader_triangle)
         if (vertexShaderCode.isNullOrEmpty() || fragmentShaderCode.isNullOrEmpty()) {
             throw RuntimeException("vertexShaderCode or fragmentShaderCode is null or empty")
         }
         // compile shader
         val vertexShaderHandler = GLUtil.compileShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode)
         val fragmentShaderHandler =
             GLUtil.compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode)
         // create and link program
         programHandle = GLUtil.createAndLinkProgram(vertexShaderHandler, fragmentShaderHandler)
     }
     /**
     * 绘制方法
     */
     fun draw(mvpMatrix: FloatArray) {
         GLES20.glUseProgram(programHandle)
         // 获取attribute变量的地址索引
         // get handle to vertex shader's vPosition member
         positionHandle = GLES20.glGetAttribLocation(programHandle, "vPosition").also {
             // enable vertex attribute，默认是disable
             GLES20.glEnableVertexAttribArray(it)
             GLES20.glVertexAttribPointer(
                 it, // 着色器中第一个顶点属性的位置
                 COORDINATE_PER_VERTEX,
                 GLES20.GL_FLOAT,
                 false,
                 vertexStride, // 连续的顶点属性组之间的间隔
                 vertexBuffer
             )
         }
         // get handle to fragment shader's vColor member
         colorHandler = GLES20.glGetUniformLocation(programHandle, "vColor").also {
             GLES20.glUniform4fv(it, 1, color, 0)
         }
         // draw triangle
         GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, triangleCoordinate.size / COORDINATE_PER_VERTEX)
         GLES20.glDisableVertexAttribArray(positionHandle)
     }
}

// 渲染器实现
class MRenderer(private var context: Context) : GLSurfaceView.Renderer {
     private val tag = MRenderer::class.Java.simpleName
     private lateinit var triangle: Triangle
     private val vPMatrix = FloatArray(16) // 模型视图投影矩阵
     private val projectionMatrix = FloatArray(16)
     private val viewMatrix = FloatArray(16)
     override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
         // 创建Surface时调用，在渲染开始时调用，用来创建渲染开始时需要的资源
         Log.d(tag, "onSurfaceCreated")
         triangle = Triangle(context)
     }
     override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
         // Surface改变大小时调用，设置视口
         Log.d(tag, "onSurfaceChanged")
         GLES20.glViewport(0, 0, width, height)
     }
     override fun onDrawFrame(gl: GL10?) {
         // 绘制当前frame，用于渲染处理具体的内容
         Log.d(tag, "onDrawFrame")
         triangle.draw(vPMatrix)
     }
}