Adreno shader test

light.frag

#define DIRECTIONAL_LIGHT_COUNT 1
#ifdef OPENGL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif

#ifndef DIRECTIONAL_LIGHT_COUNT
#define DIRECTIONAL_LIGHT_COUNT 0
#endif
#if (DIRECTIONAL_LIGHT_COUNT > 0)
#define LIGHTING
#endif

uniform vec3 u_ambientColor;
uniform vec4 u_diffuseColor;

#if defined(LIGHTING)

#if (DIRECTIONAL_LIGHT_COUNT > 0)
uniform vec3 u_directionalLightColor[DIRECTIONAL_LIGHT_COUNT];
uniform vec3 u_directionalLightDirection[DIRECTIONAL_LIGHT_COUNT];
#endif

#endif

vec4 _baseColor;

#if defined(LIGHTING)

varying vec3 v_normalVector;

vec3 computeLighting(vec3 normalVector, vec3 lightDirection, vec3 lightColor, float attenuation)
{
    float diffuse = max(dot(normalVector, lightDirection), 0.0);
     vec3 diffuseColor = lightColor * _baseColor.rgb * diffuse * attenuation;

    return diffuseColor;
}

vec3 getLitPixel()
{
    vec3 normalVector = normalize(v_normalVector);
    vec3 ambientColor = _baseColor.rgb * u_ambientColor;
    vec3 combinedColor = ambientColor;

    // Directional light contribution
    #if (DIRECTIONAL_LIGHT_COUNT > 0)
    for (int i = 0; i < DIRECTIONAL_LIGHT_COUNT; ++i)
    {
        vec3 lightDirection = normalize(u_directionalLightDirection[i] * 2.0);
        combinedColor += computeLighting(normalVector, -lightDirection, u_directionalLightColor[i], 1.0);
    }
    #endif

    return combinedColor;
}

#endif

void main()
{
    
    #if defined(LIGHTING)

    _baseColor = u_diffuseColor;
    
    gl_FragColor.a = _baseColor.a;
    gl_FragColor.rgb = getLitPixel();
    
    #else
    
    gl_FragColor = u_diffuseColor;
    
    #endif
}

light.vert

#define DIRECTIONAL_LIGHT_COUNT 1

#ifndef DIRECTIONAL_LIGHT_COUNT
#define DIRECTIONAL_LIGHT_COUNT 0
#endif
#if (DIRECTIONAL_LIGHT_COUNT > 0)
#define LIGHTING
#endif

attribute vec4 a_position;

#if defined(LIGHTING)
attribute vec3 a_normal;
#endif

uniform mat4 u_worldViewProjectionMatrix;

#if defined(LIGHTING)
uniform mat4 u_inverseTransposeWorldViewMatrix;

#if (DIRECTIONAL_LIGHT_COUNT > 0)
uniform vec3 u_directionalLightDirection[DIRECTIONAL_LIGHT_COUNT];
#endif

#endif

#if defined(LIGHTING)

varying vec3 v_normalVector;

#if (DIRECTIONAL_LIGHT_COUNT > 0) 
varying vec3 v_lightDirection[DIRECTIONAL_LIGHT_COUNT];
#endif

#endif

void main()
{
    vec4 position = a_position;
    gl_Position = u_worldViewProjectionMatrix * position;

    #if defined (LIGHTING)

    vec3 normal = a_normal;

    // Transform normal to view space.
    mat3 inverseTransposeWorldViewMatrix = mat3(u_inverseTransposeWorldViewMatrix[0].xyz, u_inverseTransposeWorldViewMatrix[1].xyz, u_inverseTransposeWorldViewMatrix[2].xyz);
    v_normalVector = inverseTransposeWorldViewMatrix * normal;

    #endif
}