Distorted Android

      {

      String error = GLES30.glGetShaderInfoLog(shaderHandle);

      switch(shaderType)

        {

        case GLES30.GL_VERTEX_SHADER  : throw new VertexCompilationException(error);

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

// CHROMA EFFECT

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

  {

  color.rgb = mix(color.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x);

  }

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

// ALPHA EFFECT (change transparency level)

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

  {

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

  }

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

// BRIGHTNESS EFFECT

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 ); 

  }

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

// CONTRAST EFFECT

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 ); 

  }

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

// SATURATION EFFECT

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

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

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

    }

#endif

uniform vec4 vUniforms[3*NUM_VERTEX];// i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].

                                     // The first vec4 is the Interpolated values,

                                     // next is half cache half Center, the third -  the Region.

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

// HELPER FUNCTIONS

//        along the force line is.

//        0<=C<1 looks completely ridiculous and C<0 destroys the system.

void deform(in int effect, inout vec3 v, inout vec3 n)

  {

  const vec2 ONE = vec2(1.0,1.0);

  n.xy += n.z*b*ps;

  }

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

// DISTORT EFFECT

// Thus we actually want to compute N(v.x,v.y) = a*(-(dx/|PS|)*f'(|PX|), -(dy/|PS|)*f'(|PX|), 1) and keep adding

// the first two components. (a is the horizontal part)

void distort(in int effect, inout vec3 v, inout vec3 n)

  {

  vec2 center = vUniforms[effect+1].yz;

  v.xy += d*force.xy;

  n.xy += n.z*b*ps;

  }

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

// SINK EFFECT

// Pull P=(v.x,v.y) towards center of the effect with P' = P + (1-h)*dist(S-P)

// when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(S-P)

void sink(in int effect,inout vec3 v)

  {

  vec2 center = vUniforms[effect+1].yz;

  v.xy += t*ps;

  }

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

// PINCH EFFECT

// with P' = P + (1-h)*dist(line to P)

// when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(line to P)

void pinch(in int effect,inout vec3 v)

  {

  vec2 center = vUniforms[effect+1].yz;

  v.xy += t*dot(ps,dir)*dir;

  }

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

// SWIRL EFFECT

// This effect rotates the current vertex V by vInterpolated.x radians clockwise around the circle dilated

// by (1-d) around the center of the effect S.

void swirl(in int effect, inout vec3 v)

  {

  vec2 center  = vUniforms[effect+1].yz;

                                                               // bitmap some points end up with d2<0 and they disappear off view.

  v.xy += min(d1_circle,d1_bitmap)*(PS - PS2/(1.0-d2));        // if d2=1 (i.e P=center) we should have P unchanged. How to do it?

  }

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

// WAVE EFFECT

//

// Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.

void wave(in int effect, inout vec3 v, inout vec3 n)

  {

  vec2 center     = vUniforms[effect+1].yz;

      }

    }

  }

#endif

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

void main()

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

    {

    j+=3;

    }