2D triangle with two textures

Hello.

I would like to create triangle with separate textures on each side. I was googling for such a scenario, but found nothing, only managed to create triangle with single texture.

Code:

class Triangle {
    private val vertexShaderCode =
    // This matrix member variable provides a hook to manipulate
        // the coordinates of the objects that use this vertex shader
        "uniform mat4 uMVPMatrix;" +
                "attribute vec4 vPosition;" +
                "attribute vec2 TexCoordinate;" +
                "varying vec2 v_TexCoordinate;" +
                "void main() {" +
                "  v_TexCoordinate = TexCoordinate;" +
                // the matrix must be included as a modifier of gl_Position
                // Note that the uMVPMatrix factor *must be first* in order
                // for the matrix multiplication product to be correct.
                "  gl_Position = uMVPMatrix * vPosition;" +
                "}"

    // Use to access and set the view transformation
    private var vPMatrixHandle: Int = 0


    private val fragmentShaderCode =
        "precision mediump float;" +
                "uniform sampler2D u_Texture;" +
                "varying vec2 v_TexCoordinate;" +
                "void main() {" +
                "  gl_FragColor = texture2D(u_Texture, v_TexCoordinate);" +
                "}"

   private var positionHandle: Int = 0

    // number of coordinates per vertex in this array
    private val COORDS_PER_VERTEX = 3
    private var triangleCoords = floatArrayOf(
        0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        1.0f, 0.0f, 0.0f
    )

    private val vertexCount: Int = triangleCoords.size / COORDS_PER_VERTEX
    private val vertexStride: Int = COORDS_PER_VERTEX * 4 // 4 bytes per vertex

    private var vertexBuffer: FloatBuffer =
        // (number of coordinate values * 4 bytes per float)
        ByteBuffer.allocateDirect(triangleCoords.size * 4).run {
            // use the device hardware's native byte order
            order(ByteOrder.nativeOrder())

            // create a floating point buffer from the ByteBuffer
            asFloatBuffer().apply {
                // add the coordinates to the FloatBuffer
                put(triangleCoords)
                // set the buffer to read the first coordinate
                position(0)
            }
        }
    fun draw(mvpMatrix: FloatArray) {
        GLES20.glUseProgram(mProgram)

        // get handle to vertex shader's vPosition member
        positionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition").also {
            // Enable a handle to the triangle vertices
            GLES20.glEnableVertexAttribArray(it)

            // Prepare the triangle coordinate data
            GLES20.glVertexAttribPointer(
                it,
                COORDS_PER_VERTEX,
                GLES20.GL_FLOAT,
                false,
                vertexStride,
                vertexBuffer
            )
        }

        // get handle to shape's transformation matrix
        vPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix")

        // Pass the projection and view transformation to the shader
        GLES20.glUniformMatrix4fv(vPMatrixHandle, 1, false, mvpMatrix, 0)

        // Draw the triangle
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount)

        val textureUniformHandle: Int = GLES20.glGetUniformLocation(mProgram, "u_Texture")

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataHandle)
        GLES20.glUniform1i(textureUniformHandle, 0)

        val textureCoordinateData = floatArrayOf(
            // Front face
            0.0f, 0.0f,
            0.0f, 1.0f,
            1.0f, 0.0f,
            1.0f, 1.0f
        )

        val textureCoordinates: FloatBuffer =
            ByteBuffer.allocateDirect(textureCoordinateData.size * 4).run {
                order(ByteOrder.nativeOrder())

                asFloatBuffer().apply {
                    put(textureCoordinateData)
                    position(0)
                }
            }

        val textureCoordinateHandle = GLES20.glGetAttribLocation(mProgram, "TexCoordinate").also {

            GLES20.glEnableVertexAttribArray(it)
            GLES20.glVertexAttribPointer(
               it,
                2,
                GLES20.GL_FLOAT,
                false,
                8,
                textureCoordinates
            )
        }

        // Disable vertex array
        GLES20.glDisableVertexAttribArray(positionHandle)

    }
}

Could anyone give advice how to create triangle with two different textures on each side?

If problem is easy to be searched with google - sorry, I was trying that and found nothing.

Have the fragment shader examine the built-in variable gl_FrontFacing.

Alternatively, render the object twice with different glCullFace settings (and with GL_CULL_FACE enabled).