Distorted Android

precision highp float;

uniform sampler2D u_Texture;    // The input texture.

varying vec3 v_Position;		// Interpolated position for this fragment.

varying vec4 v_Color;          	// This is the color from the vertex shader interpolated across the triangle per fragment.

varying vec3 v_Normal;         	// Interpolated normal for this fragment.

varying vec2 v_TexCoordinate;   // Interpolated texture coordinate per fragment.

uniform int fNumEffects;                // total number of fragment effects

#if NUM_FRAGMENT>0

uniform int fType[NUM_FRAGMENT];        // their types.

uniform vec3 fUniforms[3*NUM_FRAGMENT]; // i-th effect is 3 consecutive vec3's: [3*i], [3*i+1], [3*i+2]. first 4 floats are the Interpolated values,

                                        // next 5 describe the Region, i.e. area over which the effect is active.

                                        // Important note: here the Region is written in a different order than in the Vertex shader.

const vec3 LUMI = vec3( 0.2125, 0.7154, 0.0721 );                                        

//////////////////////////////////////////////////////////////////////////////////////////////

// macroblocks

void macroblock(float degree, int effect, inout vec2 tex)

  {

  vec2 one = vec2(1.0,1.0);  

  vec2 a = degree*(fUniforms[effect].yz-one)+one;

  tex = ( max((1.0-degree)*tex,floor(tex*a)) + degree*vec2(0.5,0.5) ) / a;

  }

//////////////////////////////////////////////////////////////////////////////////////////////

// change the RGB values

void chroma(float degree, int effect, inout vec4 color)

  {

  color.rgb = mix(color.rgb, vec3(fUniforms[effect].yz,fUniforms[effect+1].x), degree*fUniforms[effect].x); 

  }

//////////////////////////////////////////////////////////////////////////////////////////////

// change the transparency level

void alpha(float degree, int effect, inout vec4 color)

  {

  color.a *= (degree*(fUniforms[effect].x-1.0)+1.0); 

  }

//////////////////////////////////////////////////////////////////////////////////////////////

// change the brightness level

void brightness(float degree, int effect, inout vec4 color)

  {

  color.rgb = mix(vec3(0.0,0.0,0.0), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 ); 

  }

//////////////////////////////////////////////////////////////////////////////////////////////

// change the contrast level

void contrast(float degree, int effect, inout vec4 color)

  {

  color.rgb = mix(vec3(0.5,0.5,0.5), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 ); 

  }

//////////////////////////////////////////////////////////////////////////////////////////////

// change the saturation level

void saturation(float degree, int effect, inout vec4 color)

  {

  float luminance = dot(LUMI,color.rgb);

  color.rgb = mix(vec3(luminance,luminance,luminance), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 ); 

  }

#endif

//////////////////////////////////////////////////////////////////////////////////////////////

void main()                    		

  {  

  vec2 tex = v_TexCoordinate;

  vec4 col = v_Color;

  vec2 diff;

  float pointDegree;

#if NUM_FRAGMENT>0  

  for(int i=0; i<fNumEffects; i++)

    {

    diff = (v_Position.xy - fUniforms[3*i+2].yz)/fUniforms[3*i+1].yz;

    pointDegree = max(0.0,1.0-dot(diff,diff));

    //switch(fType[i])

    //  {

    //  case MACROBLOCK        : macroblock(sign(pointDegree),3*i,tex); break;

    //  case CHROMA            : chroma    (sign(pointDegree),3*i,col); break;

    //  case SMOOTH_CHROMA     : chroma    (     pointDegree ,3*i,col); break;

    //  case ALPHA             : alpha     (sign(pointDegree),3*i,col); break;

    //  case SMOOTH_ALPHA      : alpha     (     pointDegree ,3*i,col); break;

    //  case BRIGHTNESS        : brightness(sign(pointDegree),3*i,col); break;

    //  case SMOOTH_BRIGHTNESS : brightness(     pointDegree ,3*i,col); break;

    //  case CONTRAST          : contrast  (sign(pointDegree),3*i,col); break;

    //  case SMOOTH_CONTRAST   : contrast  (     pointDegree ,3*i,col); break;

    //  case SATURATION        : saturation(sign(pointDegree),3*i,col); break;

    //  case SMOOTH_SATURATION : saturation(     pointDegree ,3*i,col); break;

    //  }

         if( fType[i]==MACROBLOCK        ) macroblock(sign(pointDegree),3*i,tex);

    else if( fType[i]==CHROMA            ) chroma    (sign(pointDegree),3*i,col);

    else if( fType[i]==SMOOTH_CHROMA     ) chroma    (     pointDegree ,3*i,col);

    else if( fType[i]==ALPHA             ) alpha     (sign(pointDegree),3*i,col);

    else if( fType[i]==SMOOTH_ALPHA      ) alpha     (     pointDegree ,3*i,col);

    else if( fType[i]==BRIGHTNESS        ) brightness(sign(pointDegree),3*i,col);

    else if( fType[i]==SMOOTH_BRIGHTNESS ) brightness(     pointDegree ,3*i,col);

    else if( fType[i]==CONTRAST          ) contrast  (sign(pointDegree),3*i,col);

    else if( fType[i]==SMOOTH_CONTRAST   ) contrast  (     pointDegree ,3*i,col);

    else if( fType[i]==SATURATION        ) saturation(sign(pointDegree),3*i,col);

    else if( fType[i]==SMOOTH_SATURATION ) saturation(     pointDegree ,3*i,col);

    }

#endif

  gl_FragColor = (col * 0.5 * (v_Normal.z+1.0) * texture2D(u_Texture, tex));

  }