open class GLTextureView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) :
    TextureView(context, attrs, defStyleAttr),
    TextureView.SurfaceTextureListener,
    View.OnLayoutChangeListener {
}

override fun onSurfaceTextureAvailable(surface: SurfaceTexture, width: Int, height: Int) {
        surfaceCreated(surface)
        surfaceChanged(surface, 0, width, height)
    }
    override fun onSurfaceTextureSizeChanged(surface: SurfaceTexture, width: Int, height: Int) {
        surfaceChanged(surface, 0, width, height)
    }
    override fun onSurfaceTextureDestroyed(surface: SurfaceTexture): Boolean {
        surfaceDestroyed(surface)
        return true
    }
    override fun onSurfaceTextureUpdated(surface: SurfaceTexture) {
    }

override fun onLayoutChange(
        v: View?, left: Int, top: Int,
        right: Int,
        bottom: Int,
        oldLeft: Int,
        oldTop: Int,
        oldRight: Int,
        oldBottom: Int
    ) {
        surfaceChanged(surfaceTexture, 0, right - left, bottom - top)
    }

fun Resources.getRawTextFile(@RawRes resource: Int): String =
   openRawResource(resource).bufferedReader().use { it.readText() }

#version 300 es
uniform mat4 uMVPMatrix;
uniform mat4 uSTMatrix;
in vec3 inPosition;
in vec2 inTextureCoord;
out vec2 textureCoord;
void main() {
   gl_Position = uMVPMatrix * vec4(inPosition.xyz, 1);
   textureCoord = (uSTMatrix * vec4(inTextureCoord.xy, 0, 0)).xy;
}

#version 300 es

uniform vec4 uMyUniform;

in vec2 textureCoord;
out vec4 fragColor;

void main() {
   fragColor = vec4(textureCoord.x, textureCoord.y, 1.0, 1.0) * uMyUniform;
}

#version 300 es
precision mediump float;
uniform vec4 uMyUniform;
in vec2 textureCoord;
out vec4 fragColor;
void main() {
    fragColor = vec4(textureCoord.x, textureCoord.y, 1.0, 1.0) * uMyUniform;
}

private const val FLOAT_SIZE_BYTES = 4 // размер Float
private const val TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES // 5 float’ов для каждой вершины (3 float’а на позицию и 2 на координаты текстуры)
private const val TRIANGLE_VERTICES_DATA_POS_OFFSET = 0 // позиция начинается с начала массива каждой вершины
private const val TRIANGLE_VERTICES_DATA_UV_OFFSET = 3 // координаты текстуры начиная с 3-го float’а (4-й и 5-й float’ы)
// атрибуты вершинного шейдера
const val VERTEX_SHADER_IN_POSITION = "inPosition"
const val VERTEX_SHADER_IN_TEXTURE_COORD = "inTextureCoord"
const val VERTEX_SHADER_UNIFORM_MATRIX_MVP = "uMVPMatrix"
const val VERTEX_SHADER_UNIFORM_MATRIX_STM = "uSTMatrix"
const val FRAGMENT_SHADER_UNIFORM_MY_UNIFORM = "uMyUniform"
private const val UNKNOWN_PROGRAM = -1
private const val UNKNOWN_ATTRIBUTE = -1

private var vertexShaderSource : String, // исходный код вершинного шейдера
private var fragmentShaderSource : String, // исходный код фрагментного шейдера
QuadRender.kt на GitHub

private val quadVertices: FloatBuffer
init {
  // задаем массив вершин четырехугольника
   val quadVerticesData = floatArrayOf(
       // [x,y,z, U,V]
       -1.0f, -1.0f, 0f, 0f, 1f,
       1.0f, -1.0f, 0f, 1f, 1f,
       -1.0f, 1.0f, 0f, 0f, 0f,
       1.0f, 1.0f, 0f, 1f, 0f
   )
   quadVertices = ByteBuffer
       .allocateDirect(quadVerticesData.size * FLOAT_SIZE_BYTES)
       .order(ByteOrder.nativeOrder())
       .asFloatBuffer()
       .apply {
           put(quadVerticesData).position(0)
       }
}

private val matrixMVP = FloatArray(16)
private val matrixSTM = FloatArray(16)

init {
 // код, который мы добавили ранее
  Matrix.setIdentityM(matrixSTM, 0)
}

private var inPositionHandle = UNKNOWN_ATTRIBUTE
private var inTextureHandle = UNKNOWN_ATTRIBUTE
private var uMVPMatrixHandle = UNKNOWN_ATTRIBUTE
private var uSTMatrixHandle = UNKNOWN_ATTRIBUTE
private var uMyUniform = UNKNOWN_ATTRIBUTE

private var program = UNKNOWN_PROGRAM

override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
  //создаем программу шейдера из исходного кода
createProgram(vertexShaderSource, fragmentShaderSource)
  // связываем вектор атрибутов шейдера
   inPositionHandle = GLES20.glGetAttribLocation(program, VERTEX_SHADER_IN_POSITION)
   checkGlError("glGetAttribLocation $VERTEX_SHADER_IN_POSITION")
   if (inPositionHandle == UNKNOWN_ATTRIBUTE) throw RuntimeException("Could not get attrib location for $VERTEX_SHADER_IN_POSITION")
   inTextureHandle = GLES20.glGetAttribLocation(program, VERTEX_SHADER_IN_TEXTURE_COORD)
   checkGlError("glGetAttribLocation $VERTEX_SHADER_IN_TEXTURE_COORD")
   if (inTextureHandle == UNKNOWN_ATTRIBUTE) throw RuntimeException("Could not get attrib location for $VERTEX_SHADER_IN_TEXTURE_COORD")
   uMVPMatrixHandle = GLES20.glGetUniformLocation(program, VERTEX_SHADER_UNIFORM_MATRIX_MVP)
   checkGlError("glGetUniformLocation $VERTEX_SHADER_UNIFORM_MATRIX_MVP")
   if (uMVPMatrixHandle == UNKNOWN_ATTRIBUTE) throw RuntimeException("Could not get uniform location for $VERTEX_SHADER_UNIFORM_MATRIX_MVP")
   uSTMatrixHandle = GLES20.glGetUniformLocation(program, VERTEX_SHADER_UNIFORM_MATRIX_STM)
   checkGlError("glGetUniformLocation $VERTEX_SHADER_UNIFORM_MATRIX_STM")
   if (uSTMatrixHandle == UNKNOWN_ATTRIBUTE) throw RuntimeException("Could not get uniform location for $VERTEX_SHADER_UNIFORM_MATRIX_STM")
  // (!) связываем атрибуты фрагментного шейдера
   uMyUniform = GLES30.glGetUniformLocation(program, FRAGMENT_SHADER_UNIFORM_MY_UNIFORM)
   checkGlError("glGetUniformLocation $FRAGMENT_SHADER_UNIFORM_MY_UNIFORM")
   if (uMyUniform == UNKNOWN_ATTRIBUTE) throw RuntimeException("Could not get uniform location for $FRAGMENT_SHADER_UNIFORM_MY_UNIFORM")
}

/**
* Создаем программу шейдера из исходного кода вершинного и фрагментного шейдера
*/
private fun createProgram(vertexSource: String, fragmentSource: String): Boolean {
   if (program != UNKNOWN_PROGRAM) {
      // удаляем программу
       GLES30.glDeleteProgram(program)
       program = UNKNOWN_PROGRAM
   }
  // загружаем вершинный шейдер
   val vertexShader = loadShader(GLES30.GL_VERTEX_SHADER, vertexSource)
   if (vertexShader == UNKNOWN_PROGRAM) {
       return false
   }
   // загружаем фрагментный шейдер
   val pixelShader = loadShader(GLES30.GL_FRAGMENT_SHADER, fragmentSource)
   if (pixelShader == UNKNOWN_PROGRAM) {
       return false
   }
   program = GLES30.glCreateProgram()
   if (program != UNKNOWN_PROGRAM) {
       GLES30.glAttachShader(program, vertexShader)
       checkGlError("glAttachShader: vertex")
       GLES30.glAttachShader(program, pixelShader)
       checkGlError("glAttachShader: pixel")
       return linkProgram()
   }
   return true
}
private fun linkProgram(): Boolean {
   if (program == UNKNOWN_PROGRAM) {
       return false
   }
   GLES30.glLinkProgram(program)
   val linkStatus = IntArray(1)
   GLES30.glGetProgramiv(program, GLES30.GL_LINK_STATUS, linkStatus, 0)
   if (linkStatus[0] != GLES30.GL_TRUE) {
       Log.e(TAG, "Could not link program: ")
       Log.e(TAG, GLES30.glGetProgramInfoLog(program))
       GLES30.glDeleteProgram(program)
       program = UNKNOWN_PROGRAM
       return false
   }
   return true
}
private fun loadShader(shaderType: Int, source: String): Int {
   var shader = GLES30.glCreateShader(shaderType)
   if (shader != UNKNOWN_PROGRAM) {
       GLES30.glShaderSource(shader, source)
       GLES30.glCompileShader(shader)
       val compiled = IntArray(1)
       GLES30.glGetShaderiv(shader, GLES30.GL_COMPILE_STATUS, compiled, 0)
       if (compiled[0] == UNKNOWN_PROGRAM) {
           Log.e(TAG, "Could not compile shader $shaderType:")
           Log.e(TAG, GLES30.glGetShaderInfoLog(shader))
           GLES30.glDeleteShader(shader)
           shader = UNKNOWN_PROGRAM
       }
   }
   return shader
}
private fun checkGlError(op: String) {
   var error: Int
   while (GLES30.glGetError().also { error = it } != GLES30.GL_NO_ERROR) {
       Log.e(TAG, "$op: glError $error")
       throw RuntimeException("$op: glError $error")
   }

override fun onDrawFrame(gl: GL10?) {
   // очищаем наш "экран"
   GLES30.glClearColor(0.0f, 0.0f, 0.0f, 0.0f)
   GLES30.glClear(GLES30.GL_DEPTH_BUFFER_BIT or GLES30.GL_COLOR_BUFFER_BIT)
   // используем программу
   GLES30.glUseProgram(program)
   // устанавливаем ввод шейдера (встроенные атрибуты)
   setAttribute(inPositionHandle, VERTEX_SHADER_IN_POSITION, 3, TRIANGLE_VERTICES_DATA_POS_OFFSET) // 3 потому что 3 float’а на позицию
   setAttribute(inTextureHandle, VERTEX_SHADER_IN_TEXTURE_COORD, 2, TRIANGLE_VERTICES_DATA_UV_OFFSET) // 2 потому что 2 float’а на координаты текстуры
  // обновляем матрицу
   Matrix.setIdentityM(matrixMVP, 0)
   GLES30.glUniformMatrix4fv(uMVPMatrixHandle, 1, false, matrixMVP, 0)
   GLES30.glUniformMatrix4fv(uSTMatrixHandle, 1, false, matrixSTM, 0)
  // (!) обновляем формы для фрагментного шейдера
   val uMyUniformValue = floatArrayOf(1.0f, 0.75f, 0.95f, 1f) // некоторые значения, которые мы собираемся передать фрагментному шейдеру
   GLES30.glUniform4fv(uMyUniform, 1, uMyUniformValue, 0)
   // активируем смешивание текстур (для поддержки прозрачности)
   GLES30.glBlendFunc(GLES30.GL_SRC_ALPHA, GLES30.GL_ONE_MINUS_SRC_ALPHA)
   GLES30.glEnable(GLES20.GL_BLEND)
  // отрисовываем наши четырехугольники
   GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4)
   checkGlError("glDrawArrays")
   GLES30.glFinish()
}

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

private const val OPENGL_VERSION = 3
class ShaderView @JvmOverloads constructor(
   context: Context,
   attrs: AttributeSet? = null,
   defStyleAttr: Int = 0
) :
   GLTextureView(context, attrs, defStyleAttr) {
   init {
      // определяем версию OpenGL
       setEGLContextClientVersion(OPENGL_VERSION)
      // загружаем исходный код шейдеров из файлов 
       val vsh = context.resources.getRawTextFile(R.raw.vertex_shader)
       val fsh = context.resources.getRawTextFile(R.raw.fragment_shader)
      // устанавливаем рендерер
       setRenderer(QuadRender(vertexShaderSource = vsh, fragmentShaderSource = fsh))
       // устанавливаем режим рендеринга RENDERMODE_WHEN_DIRTY или RENDERMODE_CONTINUOUSLY
       setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY) // или GLSurfaceView.RENDERMODE_CONTINUOUSLY если нужно обновлять его на каждом кадре
   }
}

#version 300 es
precision mediump float;
uniform sampler2D uTexture;
in vec2 textureCoord;
out vec4 fragColor;
void main() {
   fragColor = texture(uTexture, textureCoord);
}

fun Resources.loadBitmapForTexture(@DrawableRes drawableRes: Int): Bitmap {
   val options = BitmapFactory.Options()
   options.inScaled = false // по умолчанию true. false, если нам нужно масштабируемое изображение
  // загрузка из ресурсов
   return BitmapFactory.decodeResource(this, drawableRes, options)
}
/**
* Загрузка текстуры из Bitmap и запись ее в видеопамять
* @needToRecycle - нужно ли нам повторно использовать текущий Bitmap, когда пишем это GPI?
*/
@Throws(RuntimeException::class)
fun Bitmap.toGlTexture(needToRecycle: Boolean = true, textureSlot: Int = GLES30.GL_TEXTURE0): Int {
  // инициализация текстуры
   val textureIds = IntArray(1)
   GLES30.glGenTextures(1, textureIds, 0) // генерируем ID для текстуры
   if (textureIds[0] == 0) {
       throw java.lang.RuntimeException("It's not possible to generate ID for texture")
   }
   GLES30.glActiveTexture(textureSlot) // активируем слот #0 для текстуры
   GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureIds[0]) // привязываем текстуру по ID к активному слоту
  // фильтры текстуры
   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)
  // записываем растровое изображение в GPU
   GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, this, 0)
  // нам больше не нужно это растровое изображение
   if (needToRecycle) {
       this.recycle()
   }
  // отвязываем текстуру от слота
   GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0)
   return textureIds[0]
}

uTextureHandle = GLES30.glGetUniformLocation(program, FRAGMENT_SHADER_UNIFORM_TEXTURE)
uTextureId = textureBitmap.toGlTexture(needToRecycle = true, GLES30.GL_TEXTURE0)

GLES30.glUniform1i(uTextureHandle, 0) // 0 as far as it's slot number 0// 0 если номер слота 0
GLES30.glActiveTexture(GLES30.GL_TEXTURE0) // тот же слот текстуры, который мы использовали при инициализации
GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, uTextureId)