OpenGL ES 2.0 / GLSL não renderiza dados (Kotlin)

Estou tentando implementar um programa de sombreamento básico com GLES 2/3 e reuni este código de vários tutoriais. Tudo parece correto para mim e compila bem, mas nada aparece na minha tela.

Ele renderizou bem até que eu adicionei dados normais e de posição de luz, então ele quebrou e eu não consegui encontrar uma maneira de consertar.

Alguém pode ver o que há de errado aqui?

class MyRenderer:GLSurfaceView.Renderer{

    var glProgram = -1
    var uMV       = -1
    var uMVP      = -1
    var uLightPos = -1
    var aPosition = -1
    var aNormal   = -1
    var aColor    = -1

    val verts = arrayOf(0f,1f,0f, -1f,0f,0f,  1f,0f,0f)
    val vBuf  = allocateDirect(verts.size*4).order(nativeOrder()).asFloatBuffer()
    val norms = arrayOf(0f,0f,-1f,  0f,0f,-1f,  0f,0f,-1f)
    val nBuf  = allocateDirect(norms.size*4).order(nativeOrder()).asFloatBuffer()

    override fun onSurfaceCreated(g:GL10,c:EGLConfig) {
        glClearColor(0f,0f,0f,1f)
        glClearDepthf(1f)
        glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)

        glProgram = glCreateProgram()

        val vShader = glCreateShader(GL_VERTEX_SHADER)
        glShaderSource(vShader,"#version 100\n                    " +
            "uniform   mat4 u_mvMat;                              " +
            "uniform   mat4 u_mvpMat;                             " +
            "uniform   vec3 u_LightPos;                           " +
            "attribute vec4 a_Position;                           " +
            "attribute vec3 a_Normal;                             " +
            "attribute vec4 a_Color;                              " +
            "varying   vec4 v_Color;                              " +
            "void main(){                                         " +
            "   vec3 vertex = vec3(u_mvMat*a_Position);           " +
            "   vec3 normal = vec3(u_mvMat*vec4(a_Normal,0.0));   " +
            "   vec3 lightVector = normalize(u_LightPos-vertex);  " +
            "   float distance = length(u_LightPos-vertex);       " +
            "   float diffuse = max(dot(normal,lightVector),0.1)  " +
            "                   / (1.0+distance*distance/4.0);    " +
            "   v_Color = a_Color*diffuse;                        " +
            "   gl_Position = u_mvpMat*a_Position;}               " )
        glCompileShader(vShader)
        glAttachShader(glProgram,vShader)

        val fShader = glCreateShader(GL_FRAGMENT_SHADER)
        glShaderSource(fShader,"#version 100\n                    " +
            "precision mediump float;                             " +
            "varying vec4 v_Color;                                " +
            "void main(){                                         " +
            "   gl_FragColor = v_Color;}                          " )
        glCompileShader(fShader)
        glAttachShader(glProgram,fShader)

        glLinkProgram(glProgram)
        glUseProgram(glProgram)

        uMVP      = glGetUniformLocation(glProgram,"u_mvpMat")
        uMV       = glGetUniformLocation(glProgram,"u_mvMat")
        uLightPos = glGetUniformLocation(glProgram,"u_LightPos")
        aPosition = glGetAttribLocation (glProgram,"a_Position")
        aNormal   = glGetAttribLocation (glProgram,"a_Normal")
        aColor    = glGetAttribLocation (glProgram,"a_Color")

        glVertexAttribPointer(aPosition,4,GL_FLOAT,false,3*4,vBuf)
        glEnableVertexAttribArray(aPosition)
        glVertexAttribPointer(aNormal,4,GL_FLOAT,false,3*4,nBuf)
        glEnableVertexAttribArray(aNormal)

        val modelM = FloatArray(16)
        setIdentityM(modelM,0)
        val viewM = FloatArray(16)
        setLookAtM(viewM,0,  0f,0f,-5f,  0f,0f,0f,  0f,0f,1f)
        val projM = FloatArray(16)
        frustumM(projM,0, -2f,2f, 1f,-1f, 1f,50f)
        val mvM = FloatArray(16)
        multiplyMM(mvM,0,viewM,0,modelM,0)
        glUniformMatrix4fv(uMV,1,false,mvM,0)
        val mvpM = FloatArray(16)
        multiplyMM(mvpM,0,projM,0,mvM,0)
        glUniformMatrix4fv(uMVP,1,false,mvpM,0)

        glUniform3v(uLightPos,-1f,-10f,-1f)

        glVertexAttrib4f(aColor,1f,1f,1f,1f)
        glDrawArrays(GL_TRIANGLES,0,verts.size/3)
    }
    override fun onSurfaceChanged(g:GL10,w:Int,h:Int){}
    override fun onDrawFrame(g:GL10){}
}

Se você deseja usar valores de cor no intervalo [0,0, 1,0], então você deve usar em glVertexAttrib4fvez de glVertexAttribI4i:

glVertexAttribI4i(aColor,1,1,1,1)

glVertexAttrib4f(aColor,1.0f,1.0f,1.0f,1.0f)

glVertexAttribI* assume que os valores são valores de ponto fixo com sinal ou sem sinal no intervalo [-2147483647, 2147483647] ou [0, 4294967295]. Um valor de 1 é quase preto.

O tipo de u_LightPosé ponto flutuante ( vec3):

uniform vec3 u_LightPos; 

Você deve usar, em glUniform3fvez de glUniform3idefinir o valor de uma variável uniforme de ponto flutuante:

glUniform3i(uLightPos,-1,-10,-1)

glUniform3f(uLightPos,-1f,-10f,-1f)

Recomendo verificar se o shader foi cumprido com sucesso por glGetShaderiv(parâmetro GL_COMPILE_STATUS). Mensagens de erro de compilação podem ser recuperadas porglGetShaderInfoLog

Eu recomendo adicionar um componente de luz ambiente (por motivos de depuração), por exemplo:

v_Color = a_Color*(diffuse + 0.5);

Se você pode "ver" a geometria com a luz ambiente, existem alguns problemas possíveis:

1. a fonte de luz está no lado posterior da geometria, portanto, o lado posterior está aceso, mas não o lado frontal. Isso faz com que apenas o lado quase preto, não iluminado, seja visível do ponto de vista.

2. A distância da fonte de luz à geometria é "muito grande". distancetorna-se um valor muito grande e, portanto, diffuseé muito pequeno e toda a geometria é quase preta.

3. A fonte de luz está no volume fechado da geometria.

4. Todos os vetores normais apontam para longe da câmera. Isso pode fazer com que dot(normal, lightVector)seja inferior a 0,0.