GLSL Fragment shader won't compile with a texture2D call uncommented

Question

I have a N910f note 4 with the last lollipop 5.0.1. Well, the fragment shader isn't compilling, but if i comment out the line of texture sampling (texture2D call) the shader compiles. I don't know what happends to the compiler because of Log.e(TAG, GLES20.glGetShaderInfoLog(shader)) call is not throwing any information.

This is my fragment glsl code:

#define numLights 1
#pragma glsl

precision mediump float;

struct LightSourceParameters {
    vec3 ambient;
    vec3 lightColor;
    vec4 position;
    float spotExponent;
    float spotCutoff; // (range: [0.0,90.0], 180.0)
    vec3 spotDirection;
    float constantAttenuation;
    float linearAttenuation;
    float quadraticAttenuation;
};
uniform LightSourceParameters LightSource[numLights];

struct MaterialParameters {
    vec4 emission;
    vec4 ambient;
    vec4 diffuse;
    vec4 specular;
    float shininess;
    bool hasDiffuseTexture;
    bool hasSpecularTexture;
    bool hasEmissionTexture;
    bool hasAmbientTexture;
    bool hasNormalTexture;
    sampler2D diffuseTexture;
    sampler2D specularTexture;
    sampler2D emissionTexture;
    sampler2D ambientTexture;
    sampler2D normalTexture;
};
uniform MaterialParameters Material;

varying vec2 outTextCoord;
varying vec3 outNormal;
varying vec3 outViewVector;
varying vec3 outLightVector[numLights];

/* Declaramos cabecera de funcion, necesaria para que GLSL no diga que la funcion no existe, al definirse despues de main */
vec4 computeLight(in MaterialParameters material, in LightSourceParameters lightSource, in vec3 normal, in vec2 textCoord, in vec3 lightVector, in vec3 halfVector);
vec4 computeEmissionLight(in MaterialParameters material, in vec2 textCoord);

void main(){

    // Normalize the incoming vectors
    vec3 normal = normalize(outNormal);
    vec3 viewVector = normalize(outViewVector);

    // BACKFACE CULLING:
    float NdotVV = dot(normal,viewVector);
    if (NdotVV <= 0.0) discard;


    // normalize lightvector, compute half vectors and lights
    vec4 totalColorLighting = vec4(0.0);


    for (int indexComputeLights = 0; indexComputeLights <  numLights; indexComputeLights++){

        LightSourceParameters light = LightSource[indexComputeLights];

        vec3 currentLightVector = vec3(0.0);
        vec3 currentHalfVector = vec3(0.0);


        if (length(light.ambient) == 0.0 ){ /* no es ambiental, que no tienen vector ni half vector */

            currentLightVector = outLightVector[indexComputeLights]; // normalizamos posteriormente, para poder obtener la distancia a la luz del m�dulo de este vector
            currentHalfVector = normalize(outLightVector[indexComputeLights] + outViewVector);
        }
        else {
            // nothing
        }



        /* Si la luz es ambiental, halfVector y lightVector son
         * indefinidos para esa luz, pero da igual porque no son
         * utilizados en el algoritmo que calcula las luces
         */

     /*
        totalColorLighting = totalColorLighting + computeLight(Material, light, normal, outTextCoord, currentLightVector, currentHalfVector);
        totalColorLighting = clamp(totalColorLighting,vec4(0.0),vec4(1.0));
    */
    }

    totalColorLighting = totalColorLighting + computeEmissionLight(Material, outTextCoord);
    totalColorLighting = clamp(totalColorLighting,vec4(0.0),vec4(1.0));

    /* Devolvemos el color de fragmento calculado para almacenarlo en el framebuffer */
    totalColorLighting = vec4(1.0,1.0,0.34, 0.68);
    gl_FragColor = clamp(totalColorLighting,vec4(0.0),vec4(1.0));
    // gl_FragColor = vec4(1.0)*vec4(outTextCoord,1.0,1.0);

}

vec4 computeEmissionLight(in MaterialParameters material, in vec2 textCoord){
    vec4 totalEmissionColorLighting = vec4(0.0, 0.0, 0.0, 0.0);

    if ((length(vec3(material.emission)) != 0.0) || (material.hasEmissionTexture)) {
        /* El material tiene un termino emisivo, es decir, emite luz. Lo andimos al total de color calculado */
        if (!material.hasEmissionTexture) {
            totalEmissionColorLighting = material.emission;
        }
        else {
            totalEmissionColorLighting.rgba = texture2D(material.emissionTexture, textCoord).rgba;
            // texture2D(material.diffuseTexture, textCoord);
        }

    }
    return totalEmissionColorLighting;
}

There is another method commented out of the code, computeLight.

Well, in computeEmissionLight, if I comment this, everythig goes fine:

totalEmissionColorLighting.rgba = texture2D(material.emissionTexture, textCoord).rgba; // tried also without rgba

Does somebody see something wrong, apart of my bad way of coding?

Answer 1

I do not know why your GLSL compiler is not returning a compiler info log on failure to compile this shader, but using a struct with an opaque type (e.g. sampler2D) is known to cause issues. Opaque types cannot be assigned values at shader runtime, so passing them as part of a struct to a function does not always work (some compilers allow it, many do not).

Rewriting your shader may help if your compiler is having trouble with that:

vec4 computeEmissionLight(in vec2 textCoord){
    vec4 totalEmissionColorLighting = vec4(0.0, 0.0, 0.0, 0.0);

    if ((length(vec3(Material.emission)) != 0.0) || (Material.hasEmissionTexture)) {
        /* El material tiene un termino emisivo, es decir, emite luz. Lo andimos al total de color calculado */
        if (!Material.hasEmissionTexture) {
            totalEmissionColorLighting = Material.emission;
        }
        else {
            totalEmissionColorLighting.rgba = texture2D(Material.emissionTexture, textCoord).rgba;
            // texture2D(Material.diffuseTexture, textCoord);
        }

    }
    return totalEmissionColorLighting;
}

I have written a related answer in the past that explains this in more detail, here.