evas: fix compatibility with GLES. Alpha test

Summary:
Add alpha test in shader code instead of function glAlphaFunc that doesn't supported
in GLES2.0
Add gag and TODO in shader function that generate shadow. Without it all scene is
shadowed, because shadow effect doesn't work yet.

Reviewers: cedric, Hermet

Subscribers: cedric

Differential Revision: https://phab.enlightenment.org/D2529

Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>

src/modules/evas/engines/gl_common/evas_gl_3d_shader.c

@@ -63,6 +63,8 @@ typedef enum _E3D_Uniform
    E3D_UNIFORM_FOG_FACTOR,
    E3D_UNIFORM_FOG_COLOR,
    E3D_UNIFORM_COLOR_PICK,
+   E3D_UNIFORM_ALPHATEST_COMPARISON,
+   E3D_UNIFORM_ALPHATEST_REFVALUE,
 
    E3D_UNIFORM_COUNT,
 } E3D_Uniform;
@@ -350,7 +352,9 @@ static const char *uniform_names[] =
    "uMaterialShininess",
    "uFogFactor",
    "uFogColor",
-   "uColorPick"
+   "uColorPick",
+   "uAlphaTestComparison",
+   "uAlphaTestRefValue",
 };
 
 static inline void
@@ -579,6 +583,13 @@ _uniform_upload(E3D_Uniform u, GLint loc, const E3D_Draw_Data *data)
       case E3D_UNIFORM_COLOR_PICK:
          glUniform1f(loc, data->color_pick_key);
          break;
+      case E3D_UNIFORM_ALPHATEST_COMPARISON:
+         glUniform1i(loc,
+                    (data->alpha_comparison ? data->alpha_comparison : EVAS_3D_COMPARISON_GREATER));
+         break;
+      case E3D_UNIFORM_ALPHATEST_REFVALUE:
+         glUniform1f(loc, (data->alpha_ref_value ? data->alpha_ref_value : 0.0));
+         break;
       default:
          ERR("Invalid uniform ID.");
          break;

src/modules/evas/engines/gl_common/shader_3d/color_pick_frag.shd

@@ -1,7 +1,14 @@
 uniform float uColorPick;
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 void main()
 {
-   gl_FragColor = vec4(uColorPick);
+   vec4 color = vec4(uColorPick);
+
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
+   gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
 }
 

src/modules/evas/engines/gl_common/shader_3d/diffuse_frag.shd

@@ -1,11 +1,16 @@
 FRAGMENT_SHADER_USE_TEX_COORD
 FRAGMENT_SHADER_USE_FOG
 FRAGMENT_SHADER_USE_DIFFUSE_TERM
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 void main() {
    vec4  color;
    FRAGMENT_SHADER_TEXTURE_BLEND(DIFFUSE, Diffuse)
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
    gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
    FRAGMENT_SHADER_FOG_APPLY
 }
 

src/modules/evas/engines/gl_common/shader_3d/flat_frag.shd

@@ -7,51 +7,58 @@ FRAGMENT_SHADER_USE_DIFFUSE_TERM
 FRAGMENT_SHADER_USE_SPECULAR_TERM
 FRAGMENT_SHADER_USE_AMBIENT_TERM
 FRAGMENT_SHADER_USE_EMISSION_TERM
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
-void fragmentFlat()
+vec4 fragmentFlat()
 {
    vec4 color;
-
+   vec4 fragcolor;
 #ifdef DIFFUSE
 
    FRAGMENT_SHADER_TEXTURE_BLEND(DIFFUSE, Diffuse)
-   gl_FragColor = uLightDiffuse * color * vFactor.x;
+   fragcolor = uLightDiffuse * color * vFactor.x;
 #else
-   gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+   fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 #endif //DIFFUSE
 
 #ifdef SPECULAR
 
    FRAGMENT_SHADER_TEXTURE_BLEND(SPECULAR, Specular)
-   gl_FragColor += uLightSpecular * color * vFactor.y;
+   fragcolor += uLightSpecular * color * vFactor.y;
 
 #endif //SPECULAR
 
 #ifdef SHADOWED
-   gl_FragColor *= shadow;
+   fragcolor *= shadow;
 #endif //SHADOWED
 
 #ifdef AMBIENT
 
    FRAGMENT_SHADER_TEXTURE_BLEND(AMBIENT, Ambient)
-   gl_FragColor += uLightAmbient * color;
+   fragcolor += uLightAmbient * color;
 #endif //AMBIENT
 
 #ifdef  EMISSION
 
    FRAGMENT_SHADER_TEXTURE_BLEND(EMISSION, Emission)
-   gl_FragColor += color;
+   fragcolor += color;
 #endif //EMISSION
-
+   return fragcolor;
 }
 
 void main() {
-
+   vec4 color;
 #ifdef SHADOWED
    shadow = pcf(vLightPosition, 1.0 / 200.0);
 #endif //SHADOWED
 
-   fragmentFlat();
+   color = fragmentFlat();
+
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
+   gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
 
    FRAGMENT_SHADER_FOG_APPLY
 }

src/modules/evas/engines/gl_common/shader_3d/include.shd

@@ -13,14 +13,14 @@ define(`FRAGMENT_SHADER_USE_TEXTURE', `
 #ifdef $1_TEXTURE
 uniform sampler2D  uTexture$2`0';
 uniform mat3 uTextureMatrixTransform$2`0';
-vec3 Tex0Coord$2 = 
+vec3 Tex0Coord$2 =
    vec3(vTexCoord, 1.0) * uTextureMatrixTransform$2`0';
 #endif //$1_TEXTURE
 #ifdef $1_TEXTURE_BLEND
 uniform sampler2D  uTexture$2`1';
 uniform float      uTexture$2Weight;
 uniform mat3 uTextureMatrixTransform$2`1';
-vec3 Tex1Coord$2 = 
+vec3 Tex1Coord$2 =
    vec3(vTexCoord, 1.0) * uTextureMatrixTransform$2`1';
 #endif //$1_TEXTURE_BLEND')
 
@@ -30,6 +30,12 @@ uniform float uFogFactor;
 uniform vec4  uFogColor;
 #endif //FOG_ENABLED')
 
+define(`FRAGMENT_SHADER_USE_ALPHA_TEST_GLES', `
+#ifdef GL_ES
+uniform int   uAlphaTestComparison;
+uniform float uAlphaTestRefValue;
+#endif //GL_ES')
+
 define(`FRAGMENT_SHADER_USE_SHADOWS', `
 #ifdef  SHADOWED
 varying vec4 vLightPosition;
@@ -37,6 +43,7 @@ uniform sampler2D uShadowMap;
 float shadow;
 float pcf(vec4 lpos, float size)
   {
+`#ifndef GL_ES'
      vec3 smcoord = lpos.xyz / lpos.w * 0.5 + 0.5;
      float i, j, randx, randy, shadow;
      shadow = 0.0;
@@ -44,6 +51,10 @@ float pcf(vec4 lpos, float size)
        for (j = -4.0; j < 4.0; j++)
          shadow += float(smcoord.z <= texture2D(uShadowMap, smcoord.xy + vec2(i / 8.0, j / 8.0) * size).x);
      return shadow / 64.0;
+`#else'
+   /*TODO Add algorithm generate shadow*/
+   return 1.0;
+`#endif //GL_ES'
 }
 #endif //SHADOWED')
 
@@ -106,6 +117,49 @@ uniform   vec4        uLightDiffuse;
 FRAGMENT_SHADER_USE_TEXTURE(DIFFUSE, Diffuse)
 `#endif //DIFFUSE')
 
+define(`FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY',
+`#ifdef GL_ES'
+/*uAlphaTestComparison is value of the Evas_3D_Comparison type*/
+   const float p = 1000000.0;
+   float acolor = floor($1.a * p);
+   float refvalue = floor(uAlphaTestRefValue * p);
+   if (uAlphaTestComparison == 0) discard;
+   else if (uAlphaTestComparison == 1)
+     {
+        if (acolor < refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 2)
+     {
+        if (acolor == refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 3)
+     {
+        if (acolor <= refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 4)
+     {
+        if (acolor > refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 5)
+     {
+        if (acolor != refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 6)
+     {
+        if (acolor >= refvalue) gl_FragColor = $1;
+        else discard;
+     }
+   else if (uAlphaTestComparison == 7) ;
+`#else'
+   gl_FragColor = $1;
+`#endif //GL_ES')
+
+
 define(`VERTEX_SHADER_NEED_TEX_COORD',
 `#ifdef NEED_TEX_COORD'
 varying vec2 vTexCoord;

src/modules/evas/engines/gl_common/shader_3d/normal_map_frag.shd

@@ -6,6 +6,7 @@ FRAGMENT_SHADER_USE_TEX_COORD
 FRAGMENT_SHADER_USE_FOG
 FRAGMENT_SHADER_USE_SHADOWS
 FRAGMENT_SHADER_USE_TEXTURE(NORMAL, Normal)
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 #ifndef VERTEX_TANGENT
 varying  vec3        vNormal;
@@ -40,12 +41,12 @@ vec3 perturb_normal(vec3 normal)
 }
 #endif //VERTEX_TANGENT
 
-void fragmentNormalMap()
+vec4 fragmentNormalMap()
 {
    float factor;
    vec3  normal;
    vec4  color;
-
+   vec4 fragcolor;
 #ifdef NORMAL_TEXTURE_BLEND
    normal = texture2D(uTextureNormal0, vec2(Tex0CoordNormal)).rgb * uTextureNormalWeight / texture2D(uTextureNormal0, vec2(Tex0CoordNormal)).a;
    normal += texture2D(uTextureNormal1, vec2(Tex1CoordNormal)).rgb / texture2D(uTextureNormal1, vec2(Tex1CoordNormal)).a *
@@ -80,10 +81,10 @@ void fragmentNormalMap()
 #ifdef DIFFUSE
 
         FRAGMENT_SHADER_TEXTURE_BLEND(DIFFUSE, Diffuse)
-        gl_FragColor = uLightDiffuse * color * factor;
+        fragcolor = uLightDiffuse * color * factor;
 
 #else
-        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 #endif //DIFFUSE
 
 #ifdef SPECULAR
@@ -93,44 +94,49 @@ void fragmentNormalMap()
           {
              factor = pow(factor, uMaterialShininess);
              FRAGMENT_SHADER_TEXTURE_BLEND(SPECULAR, Specular)
-             gl_FragColor += uLightSpecular * color * factor;
+             fragcolor += uLightSpecular * color * factor;
           }
 
 #endif //SPECULAR
 
 #ifdef SHADOWED
-        gl_FragColor *= shadow;
+        fragcolor *= shadow;
 #endif //SHADOWED
 
      }
    else
-     gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+     fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 
 #ifdef AMBIENT
      FRAGMENT_SHADER_TEXTURE_BLEND(AMBIENT, Ambient)
-     gl_FragColor += uLightAmbient * color;
+     fragcolor += uLightAmbient * color;
 #endif //AMBIENT
 
 #ifdef LIGHT_ATTENUATION
-   gl_FragColor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
+   fragcolor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
 #endif //LIGHT_ATTENUATION
 
 #ifdef EMISSION
 
    FRAGMENT_SHADER_TEXTURE_BLEND(EMISSION, Emission)
-   gl_FragColor += color;
+   fragcolor += color;
 
 #endif //EMISSION
-
+   return fragcolor;
 }
 
 void main() {
-
+   vec4 color;
 #ifdef SHADOWED
    shadow = pcf(vLightPosition, 1.0 / 200.0);
 #endif //SHADOWED
 
-   fragmentNormalMap();
+   color = fragmentNormalMap();
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
+   gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
 
 FRAGMENT_SHADER_FOG_APPLY
 

src/modules/evas/engines/gl_common/shader_3d/parallax_occlusion_frag.shd

@@ -2,30 +2,30 @@ varying  vec3        vLightVector;
 varying  vec3        vLightHalfVector;
 varying  vec3        vEyeVector;
 uniform  sampler2D   uTextureNormal0;
-uniform  mat3 uTextureMatrixTransformNormal0;
+uniform  mat3        uTextureMatrixTransformNormal0;
 
 #ifdef NEED_TEX_COORD
 varying vec2   vTexCoord;
-vec3 Tex0CoordNormal = 
+vec3 Tex0CoordNormal =
    vec3(vTexCoord, 1.0) * uTextureMatrixTransformNormal0;
 #endif //TEX_COORD
 
-FRAGMENT_SHADER_USE_FOG
-FRAGMENT_SHADER_USE_SHADOWS
-
 #ifdef NORMAL_TEXTURE_BLEND
 uniform  sampler2D  uTextureNormal1;
 uniform  float      uTextureNormalWeight;
 uniform mat3 uTextureMatrixTransformNormal1;
-vec3 Tex1CoordNormal = 
+vec3 Tex1CoordNormal =
    vec3(vTexCoord, 1.0) * uTextureMatrixTransformNormal1;
 #endif //NORMAL_TEXTURE_BLEND
 
+FRAGMENT_SHADER_USE_FOG
+FRAGMENT_SHADER_USE_SHADOWS
 FRAGMENT_SHADER_USE_DIFFUSE_TERM
 FRAGMENT_SHADER_USE_SPECULAR_TERM
 FRAGMENT_SHADER_USE_AMBIENT_TERM
 FRAGMENT_SHADER_USE_EMISSION_TERM
 FRAGMENT_SHADER_USE_LIGHT
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 const float parallaxScale = 0.2;
 
@@ -82,12 +82,12 @@ vec2 parallaxMapping(in vec3 view, in vec2 tex, out float parallaxHeight)
    return finalTexCoords;
 }
 
-void fragmentParallaxMap()
+vec4 fragmentParallaxMap()
 {
    float factor;
    vec3  normal;
    vec4  color;
-
+   vec4 fragcolor;
    float parallaxHeight;
    vec2 tex = parallaxMapping(vEyeVector, vec2(Tex0CoordNormal), parallaxHeight);
 
@@ -134,10 +134,10 @@ void fragmentParallaxMap()
 
 #endif //DIFFUSE_TEXTURE_BLEND
 
-        gl_FragColor = uLightDiffuse * color * factor;
+        fragcolor = uLightDiffuse * color * factor;
 
 #else
-        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 #endif //DIFFUSE
 
 #ifdef SPECULAR
@@ -159,18 +159,18 @@ void fragmentParallaxMap()
 
 #endif //SPECULAR_TEXTURE_BLEND
 
-             gl_FragColor += uLightSpecular * color * factor;
+             fragcolor += uLightSpecular * color * factor;
           }
 
 #endif //SPECULAR
 
 #ifdef SHADOWED
-        gl_FragColor *= shadow;
+        fragcolor *= shadow;
 #endif //SHADOWED
 
      }
    else
-     gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+     fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 
 #ifdef AMBIENT
 #ifdef AMBIENT_TEXTURE_BLEND
@@ -186,11 +186,11 @@ void fragmentParallaxMap()
 
 #endif //AMBIENT_TEXTURE_BLEND
 
-   gl_FragColor += uLightAmbient * color;
+   fragcolor += uLightAmbient * color;
 #endif //AMBIENT
 
 #ifdef LIGHT_ATTENUATION
-   gl_FragColor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
+   fragcolor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
 #endif //LIGHT_ATTENUATION
 
 #ifdef EMISSION
@@ -208,18 +208,24 @@ void fragmentParallaxMap()
 
 #endif //EMISSION_TEXTURE_BLEND
 
-   gl_FragColor += color;
+   fragcolor += color;
 #endif //EMISSION
-
+   return fragcolor;
 }
 
 void main() {
-
+   vec4 color;
 #ifdef SHADOWED
    shadow = pcf(vLightPosition, 1.0 / 200.0);
 #endif //SHADOWED
 
-   fragmentParallaxMap();
+   color = fragmentParallaxMap();
+
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
+   gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
 
    FRAGMENT_SHADER_FOG_APPLY
 

src/modules/evas/engines/gl_common/shader_3d/phong_frag.shd

@@ -10,13 +10,15 @@ FRAGMENT_SHADER_USE_SPECULAR_TERM
 FRAGMENT_SHADER_USE_AMBIENT_TERM
 FRAGMENT_SHADER_USE_EMISSION_TERM
 FRAGMENT_SHADER_USE_LIGHT
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
-void fragmentPhong()
+vec4 fragmentPhong()
 {
    vec3  normal = normalize(vNormal);
    vec3  lv = normalize(vLightVector);
    float factor = dot(lv, normal);
    vec4  color;
+   vec4 fragcolor;
 
 #ifdef  LIGHT_SPOT
    float f = dot(-lv, normalize(uLightSpotDir));
@@ -35,9 +37,9 @@ void fragmentPhong()
 
         FRAGMENT_SHADER_TEXTURE_BLEND(DIFFUSE, Diffuse)
 
-        gl_FragColor = uLightDiffuse * color * factor;
+        fragcolor = uLightDiffuse * color * factor;
 #else
-        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 #endif //DIFFUSE
 
    /* Specular term. */
@@ -49,46 +51,52 @@ void fragmentPhong()
 
              FRAGMENT_SHADER_TEXTURE_BLEND(SPECULAR, Specular)
 
-             gl_FragColor += uLightSpecular * color * factor;
+             fragcolor += uLightSpecular * color * factor;
           }
 #endif
 
      }
    else
-     gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+     fragcolor = vec4(0.0, 0.0, 0.0, 0.0);
 
 #ifdef  SHADOWED
-   gl_FragColor *= shadow;
+   fragcolor *= shadow;
 #endif //SHADOWED
 
 #ifdef AMBIENT
    FRAGMENT_SHADER_TEXTURE_BLEND(AMBIENT, Ambient)
 
-   gl_FragColor += uLightAmbient * color;
+   fragcolor += uLightAmbient * color;
 #endif
 
    /* Light attenuation. */
 #ifdef  LIGHT_ATTENUATION
-   gl_FragColor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
+   fragcolor /= dot(uLightAtten, vec3(1.0, vLightDist, vLightDist * vLightDist));
 #endif
 
    /* Emission term. */
 #ifdef  EMISSION
 
    FRAGMENT_SHADER_TEXTURE_BLEND(EMISSION, Emission)
-   gl_FragColor += color;
+   fragcolor += color;
 #endif
-
+   return fragcolor;
 }
 
 void main()
 {
-
+   vec4 color;
 #ifdef SHADOWED
    shadow = pcf(vLightPosition, 1.0 / 300.0);
 #endif //SHADOWED
 
-   fragmentPhong();
+   color = fragmentPhong();
+
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
+#else
+   gl_FragColor = color;
+#endif //ALPHA_TEST_ENABLED
 
    FRAGMENT_SHADER_FOG_APPLY
 }

src/modules/evas/engines/gl_common/shader_3d/shadow_map_frag.shd

@@ -1,5 +1,6 @@
 #ifdef ALPHA_TEST_ENABLED
 FRAGMENT_SHADER_USE_TEX_COORD
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 #ifdef DIFFUSE
 
@@ -23,26 +24,30 @@ vec3 Tex1CoordDiffuse =
 #endif //ALPHA_TEST_ENABLED
 
 void main() {
+
+   vec4 color;
 #ifndef NEED_TEX_COORD
    gl_FragColor = vec4(1);
 #endif
+
 #ifdef ALPHA_TEST_ENABLED
 
 #ifdef DIFFUSE_TEXTURE_BLEND
-   gl_FragColor = (texture2D(uTextureDiffuse0, vec2(Tex0CoordDiffuse)) *
+   color = (texture2D(uTextureDiffuse0, vec2(Tex0CoordDiffuse)) *
    uTextureDiffuseWeight + texture2D(uTextureDiffuse1, vec2(Tex1CoordDiffuse)) *
    (1.0 - uTextureDiffuseWeight));
 #else
 
 #ifdef DIFFUSE_TEXTURE
-   gl_FragColor = texture2D(uTextureDiffuse0, vec2(Tex0CoordDiffuse)) ;
+   color = texture2D(uTextureDiffuse0, vec2(Tex0CoordDiffuse)) ;
 #else
-   gl_FragColor = vec4(1);
+   color = vec4(1);
 #endif //DIFFUSE_TEXTURE
 
 #endif //DIFFUSE_TEXTURE_BLEND
 
-#endif //ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(color)
 
+#endif //ALPHA_TEST_ENABLED
    gl_FragColor.r = gl_FragCoord.z;
 }

src/modules/evas/engines/gl_common/shader_3d/vertex_color_frag.shd

@@ -1,10 +1,17 @@
 varying  vec4        vColor;
 
 FRAGMENT_SHADER_USE_FOG
+FRAGMENT_SHADER_USE_ALPHA_TEST_GLES
 
 void main()
 {
+
+#ifdef ALPHA_TEST_ENABLED
+   FRAGMENT_SHADER_ALPHA_TEST_GLES_APPLY(vColor)
+#else
    gl_FragColor = vColor;
+#endif //ALPHA_TEST_ENABLED
+
    FRAGMENT_SHADER_FOG_APPLY
 }