Distorted Android

  private static String mGLSL = "";

  private static int mNumEnabled = 0;

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

  static void addEffect(EffectName not_smooth, EffectName yes_smooth, String code)

    {

    mNumEnabled ++;

    mGLSL +=

         "if( fName[i]=="+not_smooth.ordinal()+")\n"

        +  "{\n"

        +  "degree = sign(degree); \n"

        +   code +"\n"

        +  "}\n"

        +"else\n"

        +"if( fName[i]=="+yes_smooth.ordinal()+")\n"

        +  "{\n"

        +   code +"\n"

        +  "}\n"

        +"else\n";

    }

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

  public static String getGLSL()

    {

    return mGLSL + "{}";

    }

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

  public static int getNumEnabled()

    {

    return mNumEnabled;

    }

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

  public static void onDestroy()

    {

    mNumEnabled = 0;

    mGLSL = "";

    }

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

  public static void enable()

    {

    addEffect( EffectName.ALPHA,EffectName.SMOOTH_ALPHA,

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

    }

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

  public static void enable()

    {

    addEffect( EffectName.BRIGHTNESS,EffectName.SMOOTH_BRIGHTNESS,

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

    }

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

  public static void enable()

    {

    addEffect( EffectName.CHROMA,EffectName.SMOOTH_CHROMA,

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

    }

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

  public static void enable()

    {

    addEffect( EffectName.CONTRAST,EffectName.SMOOTH_CONTRAST,

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

    }

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

  public static void enable()

    {

    addEffect( EffectName.SATURATION,EffectName.SMOOTH_SATURATION,

               "float luminance = dot(vec3( 0.2125, 0.7154, 0.0721 ),color.rgb);\n" +

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

    }

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

  public static void enable()

    {

    }

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

  public static void enable()

    {

    }

  private static String mGLSL = "";

  private static int mNumEnabled = 0;

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

  static void addEffect(EffectName name, String code)

    {

    mNumEnabled ++;

    mGLSL +=

        "if( vName[i]=="+name.ordinal()+")\n" +

          "{\n" +

           code +"\n" +

          "}\n" +

        "else\n";

    }

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

  public static String getGLSL()

    {

    return mGLSL + "{}";

    }

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

  public static int getNumEnabled()

    {

    return mNumEnabled;

    }

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

  public static void onDestroy()

    {

    mNumEnabled = 0;

    mGLSL = "";

    }

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

// Deform the whole shape of the Object by force V. Algorithm is as follows:

//

// Suppose we apply force (Vx,Vy) at point (Cx,Cy) (i.e. the center of the effect). Then, first of all,

// divide the rectangle into 4 smaller rectangles along the 1 horizontal + 1 vertical lines that pass

// through (Cx,Cy). Now suppose we have already understood the following case:

//

// A vertical (0,Vy) force applied to a rectangle (WxH) in size, at center which is the top-left corner

// of the rectangle.  (*)

//

// If we understand (*), then we understand everything, because in order to compute the movement of the

// whole rectangle we can apply (*) 8 times: for each one of the 4 sub-rectangles, apply (*) twice,

// once for the vertical component of the force vector, the second time for the horizontal one.

//

// Let's then compute (*):

// 1) the top-left point will move by exactly (0,Vy)

// 2) we arbitrarily decide that the top-right point will move by (|Vy|/(|Vy|+A*W))*Vy, where A is some

//    arbitrary constant (const float A below). The F(V,W) = (|Vy|/(|Vy|+A*W)) comes from the following:

//    a) we want F(V,0) = 1

//    b) we want lim V->inf (F) = 1

//    c) we actually want F() to only depend on W/V, which we have here.

// 3) then the top edge of the rectangle will move along the line Vy*G(x), where G(x) = (1 - (A*W/(|Vy|+A*W))*(x/W)^2)

// 4) Now we decide that the left edge of the rectangle will move along Vy*H(y), where H(y) = (1 - |y|/(|Vy|+C*|y|))

//    where C is again an arbitrary constant. Again, H(y) comes from the requirement that no matter how

//    strong we push the left edge of the rectangle up or down, it can never 'go over itself', but its

//    length will approach 0 if squeezed very hard.

// 5) The last point we need to compute is the left-right motion of the top-right corner (i.e. if we push

//    the top-left corner up very hard, we want to have the top-right corner not only move up, but also to

//    the left at least a little bit).

//    We arbitrarily decide that, in addition to moving up-down by Vy*F(V,W), the corner will also move

//    left-right by I(V,W) = B*W*F(V,W), where B is again an arbitrary constant.

// 6) combining 3), 4) and 5) together, we arrive at a movement of an arbitrary point (x,y) away from the

//    top-left corner:

//    X(x,y) = -B*x * (|Vy|/(|Vy|+A*W)) * (1-(y/H)^2)                               (**)

//    Y(x,y) = Vy * (1 - |y|/(|Vy|+C*|y|)) * (1 - (A*W/(|Vy|+A*W))*(x/W)^2)         (**)

//

// We notice that formulas (**) have been construed so that it is possible to continously mirror them

// left-right and up-down (i.e. apply not only to the 'bottom-right' rectangle of the 4 subrectangles

// but to all 4 of them!).

//

// Constants:

// a) A : valid values: (0,infinity). 'Bendiness' if the surface - the higher A is, the more the surface

//        bends. A<=0 destroys the system.

// b) B : valid values: <-1,1>. The amount side edges get 'sucked' inwards when we pull the middle of the

//        top edge up. B=0 --> not at all, B=1: a looot. B=-0.5: the edges will actually be pushed outwards

//        quite a bit. One can also set it to <-1 or >1, but it will look a bit ridiculous.

// c) C : valid values: <1,infinity). The derivative of the H(y) function at 0, i.e. the rate of 'squeeze'

//        surface gets along the force line. C=1: our point gets pulled very closely to points above it

//        even when we apply only small vertical force to it. The higher C is, the more 'uniform' movement

//        along the force line is.

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

  public static void enable()

    {

    addEffect( EffectName.DEFORM,

        "const vec2 ONE = vec2(1.0,1.0);  \n"

      + "const float A = 0.5; \n"

      + "const float B = 0.2; \n"

      + "const float C = 5.0; \n"

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

      + "vec2 ps     = center-v.xy; \n"

      + "vec2 aPS    = abs(ps); \n"

      + "vec2 maxps  = u_objD.xy + abs(center); \n"

      + "float d     = degree_region(vUniforms[effect+2],ps); \n"

      + "vec3 force  = vUniforms[effect].xyz * d; \n"

      + "vec2 aForce = abs(force.xy); \n"

      + "float denom = dot(ps+(1.0-d)*force.xy,ps); \n"

      + "float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0)); \n"

      + "vec2 Aw = A*maxps; \n"

      + "vec2 quot = ps / maxps; \n"

      + "quot = quot*quot; \n"                          // ( (x/W)^2 , (y/H)^2 ) where x,y are distances from V to center

      + "float denomV = 1.0 / (aForce.y + Aw.x); \n"

      + "float denomH = 1.0 / (aForce.x + Aw.y); \n"

      + "vec2 vertCorr= ONE - aPS / ( aForce+C*aPS + (ONE-sign(aForce)) ); \n" // avoid division by 0 when force and PS both are 0

      + "float mvXvert = -B * ps.x * aForce.y * (1.0-quot.y) * denomV; \n"     // impact the vertical   component of the force vector has on horizontal movement

      + "float mvYhorz = -B * ps.y * aForce.x * (1.0-quot.x) * denomH; \n"     // impact the horizontal component of the force vector has on vertical   movement

      + "float mvYvert =  force.y * (1.0-quot.x*Aw.x*denomV) * vertCorr.y; \n" // impact the vertical   component of the force vector has on vertical   movement

      + "float mvXhorz = -force.x * (1.0-quot.y*Aw.y*denomH) * vertCorr.x; \n" // impact the horizontal component of the force vector has on horizontal movement

      + "v.x -= (mvXvert+mvXhorz); \n"

      + "v.y -= (mvYvert+mvYhorz); \n"

      + "v.z += force.z*d*d*(3.0*d*d -8.0*d +6.0); \n"                         // thick bubble

      + "float b = -(12.0*force.z*d*(1.0-d)*(1.0-d)*(1.0-d))*one_over_denom; \n"

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

      );

    }

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

// Point (Px,Py) gets moved by vector (Wx,Wy,Wz) where Wx/Wy = Vx/Vy i.e. Wx=aVx and Wy=aVy where

// a=Py/Sy (N --> when (Px,Py) is above (Sx,Sy)) or a=Px/Sx (W) or a=(w-Px)/(w-Sx) (E) or a=(h-Py)/(h-Sy) (S)

// It remains to be computed which of the N,W,E or S case we have: answer: a = min[ Px/Sx , Py/Sy , (w-Px)/(w-Sx) , (h-Py)/(h-Sy) ]

// Computations above are valid for screen (0,0)x(w,h) but here we have (-w/2,-h/2)x(w/2,h/2)

//

// the vertical part

// Let |(v.x,v.y),(ux,uy)| = |PS|, ux-v.x=dx,uy-v.y=dy, f(x) (0<=x<=|SX|) be the shape of the side of the bubble.

// H(v.x,v.y) = |PS|>|SX| ? 0 : f(|PX|)

// N(v.x,v.y) = |PS|>|SX| ? (0,0,1) : ( -(dx/|PS|)sin(beta), -(dy/|PS|)sin(beta), cos(beta) ) where tan(beta) is f'(|PX|)

// ( i.e. normalize( dx, dy, -|PS|/f'(|PX|))

//

// Now we also have to take into account the effect horizontal move by V=(u_dVx[i],u_dVy[i]) will have on the normal vector.

// Solution:

// 1. Decompose the V into two subcomponents, one parallel to SX and another perpendicular.

// 2. Convince yourself (draw!) that the perpendicular component has no effect on normals.

// 3. The parallel component changes the length of |SX| by the factor of a=(|SX|-|Vpar|)/|SX| (where the length

//    can be negative depending on the direction)

// 4. that in turn leaves the x and y parts of the normal unchanged and multiplies the z component by a!

//

// |Vpar| = (u_dVx[i]*dx - u_dVy[i]*dy) / sqrt(ps_sq) = (Vx*dx-Vy*dy)/ sqrt(ps_sq)  (-Vy because y is inverted)

// a =  (|SX| - |Vpar|)/|SX| = 1 - |Vpar|/((sqrt(ps_sq)/(1-d)) = 1 - (1-d)*|Vpar|/sqrt(ps_sq) = 1-(1-d)*(Vx*dx-Vy*dy)/ps_sq

//

// Side of the bubble

//

// choose from one of the three bubble shapes: the cone, the thin bubble and the thick bubble

// Case 1:

// f(t) = t, i.e. f(x) = uz * x/|SX|   (a cone)

// -|PS|/f'(|PX|) = -|PS|*|SX|/uz but since ps_sq=|PS|^2 and d=|PX|/|SX| then |PS|*|SX| = ps_sq/(1-d)

// so finally -|PS|/f'(|PX|) = -ps_sq/(uz*(1-d))

//

// Case 2:

// f(t) = 3t^2 - 2t^3 --> f(0)=0, f'(0)=0, f'(1)=0, f(1)=1 (the bell curve)

// here we have t = x/|SX| which makes f'(|PX|) = 6*uz*|PS|*|PX|/|SX|^3.

// so -|PS|/f'(|PX|) = (-|SX|^3)/(6uz|PX|) =  (-|SX|^2) / (6*uz*d) but

// d = |PX|/|SX| and ps_sq = |PS|^2 so |SX|^2 = ps_sq/(1-d)^2

// so finally -|PS|/f'(|PX|) = -ps_sq/ (6uz*d*(1-d)^2)

//

// Case 3:

// f(t) = 3t^4-8t^3+6t^2 would be better as this satisfies f(0)=0, f'(0)=0, f'(1)=0, f(1)=1,

// f(0.5)=0.7 and f'(t)= t(t-1)^2 >=0 for t>=0 so this produces a fuller, thicker bubble!

// then -|PS|/f'(|PX|) = (-|PS|*|SX)) / (12uz*d*(d-1)^2) but |PS|*|SX| = ps_sq/(1-d) (see above!)

// so finally -|PS|/f'(|PX|) = -ps_sq/ (12uz*d*(1-d)^3)

//

// Now, new requirement: we have to be able to add up normal vectors, i.e. distort already distorted surfaces.

// If a surface is given by z = f(x,y), then the normal vector at (x0,y0) is given by (-df/dx (x0,y0), -df/dy (x0,y0), 1 ).

// so if we have two surfaces defined by f1(x,y) and f2(x,y) with their normals expressed as (f1x,f1y,1) and (f2x,f2y,1)

// then the normal to g = f1+f2 is simply given by (f1x+f2x,f1y+f2y,1), i.e. if the third components are equal, then we

// can simply add up the first and second components.

//

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

  public static void enable()

    {

    addEffect(EffectName.DISTORT,

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

      + "vec2 ps = center-v.xy; \n"

      + "vec3 force = vUniforms[effect].xyz; \n"

      + "float d = degree(vUniforms[effect+2],center,ps); \n"

      + "float denom = dot(ps+(1.0-d)*force.xy,ps); \n"

      + "float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0)); \n"          // = denom==0 ? 1000:1/denom;

       //v.z += force.z*d;                                                        // cone

       //b = -(force.z*(1.0-d))*one_over_denom;                                   //

       //v.z += force.z*d*d*(3.0-2.0*d);                                          // thin bubble

       //b = -(6.0*force.z*d*(1.0-d)*(1.0-d))*one_over_denom;                     //

      + "v.z += force.z*d*d*(3.0*d*d -8.0*d +6.0); \n"                            // thick bubble

      + "float b = -(12.0*force.z*d*(1.0-d)*(1.0-d)*(1.0-d))*one_over_denom; \n"  //

      + "v.xy += d*force.xy; \n"

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

      );

    }

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

// Pull P=(v.x,v.y) towards the line that

// a) passes through the center of the effect

// b) forms angle defined in the 2nd interpolated value with the X-axis

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

  public static void enable()

    {

    addEffect(EffectName.PINCH,

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

      + "vec2 ps = center-v.xy; \n"

      + "float h = vUniforms[effect].x; \n"

      + "float t = degree(vUniforms[effect+2],center,ps) * (1.0-h)/max(1.0,h); \n"

      + "float angle = vUniforms[effect].y; \n"

      + "vec2 dir = vec2(sin(angle),-cos(angle)); \n"

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

      );

    }

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

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

  public static void enable()

    {

    addEffect(EffectName.SINK,

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

      + "vec2 ps = center-v.xy; \n"

      + "float h = vUniforms[effect].x; \n"

      + "float t = degree(vUniforms[effect+2],center,ps) * (1.0-h)/max(1.0,h); \n"

      + "v.xy += t*ps;"

      );

    }

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

// Let d be the degree of the current vertex V with respect to center of the effect S and Region vRegion.

// 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.

  public static void enable()

    {

    addEffect(EffectName.SWIRL,

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

      + "vec2 PS = center-v.xy; \n"

      + "vec4 SO = vUniforms[effect+2]; \n"

      + "float d1_circle = degree_region(SO,PS); \n"

      + "float d1_bitmap = degree_bitmap(center,PS); \n"

      + "float alpha = vUniforms[effect].x; \n"

      + "float sinA = sin(alpha); \n"

      + "float cosA = cos(alpha); \n"

      + "vec2 PS2 = vec2( PS.x*cosA+PS.y*sinA,-PS.x*sinA+PS.y*cosA ); \n" // vector PS rotated by A radians clockwise around center.

      + "vec4 SG = (1.0-d1_circle)*SO; \n"                                // coordinates of the dilated circle P is going to get rotated around

      + "float d2 = max(0.0,degree(SG,center,PS2)); \n"                   // make it a max(0,deg) because otherwise when center=left edge of the

                                                                          // 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)); \n"        // if d2=1 (i.e P=center) we should have P unchanged. How to do it?

      );

    }

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

// Directional sinusoidal wave effect.

//

// This is an effect from a (hopefully!) generic family of effects of the form (vec3 V: |V|=1 , f(x,y) )  (*)

// i.e. effects defined by a unit vector and an arbitrary function. Those effects are defined to move each

// point (x,y,0) of the XY plane to the point (x,y,0) + V*f(x,y).

//

// In this case V is defined by angles A and B (sines and cosines of which are precomputed in

// EffectQueueVertex and passed in the uniforms).

// Let's move V to start at the origin O, let point C be the endpoint of V, and let C' be C's projection

// to the XY plane. Then A is defined to be the angle C0C' and angle B is the angle C'O(axisY).

//

// Also, in this case f(x,y) = amplitude*sin(x/length), with those 2 parameters passed in uniforms.

//

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

// How to compute any generic effect of type (*)

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

//

// By definition, the vertices move by f(x,y)*V.

//

// Normals are much more complicated.

// Let angle X be the angle (0,Vy,Vz)(0,Vy,0)(Vx,Vy,Vz).

// Let angle Y be the angle (Vx,0,Vz)(Vx,0,0)(Vx,Vy,Vz).

//

// Then it can be shown that the resulting surface, at point to which point (x0,y0,0) got moved to,

// has 2 tangent vectors given by

//

// SX = (1.0+cosX*fx , cosY*sinX*fx , |sinY|*sinX*fx);  (**)

// SY = (cosX*sinY*fy , 1.0+cosY*fy , |sinX|*sinY*fy);  (***)

//

// and then obviously the normal N is given by N= SX x SY .

//

// We still need to remember the note from the distort function about adding up normals:

// we first need to 'normalize' the normals to make their third components equal, and then we

// simply add up the first and the second component while leaving the third unchanged.

//

// How to see facts (**) and (***) ? Briefly:

// a) compute the 2D analogon and conclude that in this case the tangent SX is given by

//    SX = ( cosA*f'(x) +1, sinA*f'(x) )    (where A is the angle vector V makes with X axis )

// b) cut the resulting surface with plane P which

//    - includes vector V

//    - crosses plane XY along line parallel to X axis

// c) apply the 2D analogon and notice that the tangent vector to the curve that is the common part of P

//    and our surface (I am talking about the tangent vector which belongs to P) is given by

//    (1+cosX*fx,0,sinX*fx) rotated by angle (90-|Y|) (where angles X,Y are defined above) along vector (1,0,0).

//

//    Matrix of rotation:

//

//    |sinY|  cosY

//    -cosY  |sinY|

//

// d) compute the above and see that this is equal precisely to SX from (**).

// e) repeat points b,c,d in direction Y and come up with (***).

//

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

// Note: we should avoid passing certain combinations of parameters to this function. One such known

// combination is ( A: small but positive, B: any, amplitude >= length ).

// In this case, certain 'unlucky' points have their normals almost horizontal (they got moved by (almost!)

// amplitude, and other point length (i.e. <=amplitude) away got moved by 0, so the slope in this point is

// very steep). Visual effect is: vast majority of surface pretty much unchanged, but random 'unlucky'

// points very dark)

//

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

  public static void enable()

    {

    addEffect(EffectName.WAVE,

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

      + "float amplitude = vUniforms[effect  ].x; \n"

      + "float length    = vUniforms[effect  ].y; \n"

      + "vec2 ps = center - v.xy; \n"

      + "float deg = amplitude*degree_region(vUniforms[effect+2],ps); \n"

      + "if( deg != 0.0 && length != 0.0 ) \n"

      +   "{ \n"

      +   "float phase = vUniforms[effect  ].z; \n"

      +   "float alpha = vUniforms[effect  ].w; \n"

      +   "float beta  = vUniforms[effect+1].x; \n"

      +   "float sinA = sin(alpha); \n"

      +   "float cosA = cos(alpha); \n"

      +   "float sinB = sin(beta); \n"

      +   "float cosB = cos(beta); \n"

      +   "float angle= 1.578*(ps.x*cosB-ps.y*sinB) / length + phase; \n"

      +   "vec3 dir= vec3(sinB*cosA,cosB*cosA,sinA); \n"

      +   "v += sin(angle)*deg*dir; \n"

      +   "if( n.z != 0.0 ) \n"

      +     "{ \n"

      +     "float sqrtX = sqrt(dir.y*dir.y + dir.z*dir.z); \n"

      +     "float sqrtY = sqrt(dir.x*dir.x + dir.z*dir.z); \n"

      +     "float sinX = ( sqrtY==0.0 ? 0.0 : dir.z / sqrtY); \n"

      +     "float cosX = ( sqrtY==0.0 ? 1.0 : dir.x / sqrtY); \n"

      +     "float sinY = ( sqrtX==0.0 ? 0.0 : dir.z / sqrtX); \n"

      +     "float cosY = ( sqrtX==0.0 ? 1.0 : dir.y / sqrtX); \n"

      +     "float abs_z = dir.z <0.0 ? -(sinX*sinY) : (sinX*sinY); \n"

      +     "float tmp = 1.578*cos(angle)*deg/length; \n"

      +     "float fx =-cosB*tmp; \n"

      +     "float fy = sinB*tmp; \n"

      +     "vec3 sx = vec3 (1.0+cosX*fx,cosY*sinX*fx,abs_z*fx); \n"

      +     "vec3 sy = vec3 (cosX*sinY*fy,1.0+cosY*fy,abs_z*fy); \n"

      +     "vec3 normal = cross(sx,sy); \n"

      +     "if( normal.z<=0.0 ) \n"                   // Why this bizarre shit rather than the straightforward

      +       "{ \n"                                   //

      +       "normal.x= 0.0; \n"                      // if( normal.z>0.0 )

      +       "normal.y= 0.0; \n"                      //   {

      +       "normal.z= 1.0; \n"                      //   n.x = (n.x*normal.z + n.z*normal.x);

      +       "} \n"                                   //   n.y = (n.y*normal.z + n.z*normal.y);

                                                       //   n.z = (n.z*normal.z);

                                                       //   }

      +     "n.x = (n.x*normal.z + n.z*normal.x); \n"  //

      +     "n.y = (n.y*normal.z + n.z*normal.y); \n"  // ? Because if we do the above, my shitty Nexus4 crashes

      +     "n.z = (n.z*normal.z); \n"                 // during shader compilation!

      +     "} \n"

      +   "}"

      );

    }

import org.distorted.library.effect.FragmentEffect;

import org.distorted.library.effect.VertexEffect;

    VertexEffect.onDestroy();

    FragmentEffect.onDestroy();

import org.distorted.library.effect.FragmentEffect;

import org.distorted.library.effect.VertexEffect;

    int numF = FragmentEffect.getNumEnabled();

    int numV = VertexEffect.getNumEnabled();

    String mainVertHeader= Distorted.GLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 0 ) + "\n");

    String mainFragHeader= Distorted.GLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

    //android.util.Log.e("Effects", "enabledV= "+enabledEffectV);

    //android.util.Log.e("Effects", "enabledF= "+enabledEffectF);

    mMainProgram = new DistortedProgram( mainVertStream, mainFragStream, mainVertHeader, mainFragHeader,

                                         enabledEffectV, enabledEffectF, Distorted.GLSL, feedback);

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

  private static String insertEnabledEffects(String code, final String effects)

    {

    final String marker = "// ENABLED EFFECTS WILL BE INSERTED HERE";

    int length = marker.length();

    int place = code.indexOf(marker);

    if( place>=0 )

      {

      String begin = code.substring(0,place-1);

      String end   = code.substring(place+length);

/*

int len = begin.length();

android.util.Log.d("Program", begin.substring(len-40));

android.util.Log.d("Program", effects);

android.util.Log.d("Program", end.substring(0,40));

*/

      return begin + effects + end;

      }

    else

      {

      android.util.Log.e("Program", "Error: marker string not found in SHADER!");

      }

    return null;

    }

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

// feedback: List of 'out' variables (OpenGL ES >= 3.0 only!) that will be transferred back to CPU

// using Transform Feedback.

  public DistortedProgram(final InputStream vertex, final InputStream fragment, final String vertexHeader, final String fragmentHeader,

                          final String enabledVertex, final String enabledFragment, int glslVersion, final String[] feedback )

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    {

    mAttributeStr = (glslVersion == 100 ? "attribute " : "in ");

    mAttributeLen = mAttributeStr.length();

    mNumAttributes = 0;

    String vertexShader   = readTextFileFromRawResource(vertex  , true );

    String fragmentShader = readTextFileFromRawResource(fragment, false);

    vertexShader   = insertEnabledEffects(vertexShader  ,enabledVertex  );

    fragmentShader = insertEnabledEffects(fragmentShader,enabledFragment);

    sanitizeMaxValues();

    final int vertexShaderHandle   = compileShader(GLES30.GL_VERTEX_SHADER  , vertexHeader   + vertexShader  );

    final int fragmentShaderHandle = compileShader(GLES30.GL_FRAGMENT_SHADER, fragmentHeader + fragmentShader);

    mProgramHandle = createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, mAttributeName, glslVersion>= 300 ? feedback:null );

    mAttribute = new int[mNumAttributes];

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

      {

      mAttribute[i] = GLES30.glGetAttribLocation( mProgramHandle, mAttributeName[i]);

      }

    }

  vec4 color = TEXTURE(u_Texture,v_TexCoordinate);

  float degree;

  int effect=0;

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

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

    // ENABLED EFFECTS WILL BE INSERTED HERE

    effect+=2;

  FRAG_COLOR = vec4(color.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, color.a);

  int effect=0;

    // ENABLED EFFECTS WILL BE INSERTED HERE

    effect+=3;