Distorted Android

// macroblocks

// change the RGB values

// change the transparency level

// change the brightness level

// change the contrast level

// change the saturation level

    //switch(fType[i])  // future version of GLSL

    //  {

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

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

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

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

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

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

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

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

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

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

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

    //  }

  }

// Deform the whole shape of the bitmap by force V 

// Let (v.x,v.y) be point P (the current vertex). 

// Let vPoint[effect].xy be point S (the center of effect)

// Let vPoint[effect].xy + vRegion[effect].xy be point O (the center of the Region circle)

// Let X be the point where the halfline SP meets a) if region is non-null, the region circle b) otherwise, the edge of the bitmap. 

//

// If P is inside the Region, this function returns |PX|/||SX|, aka the 'degree' of point P. Otherwise, it returns 0. 

//

// We compute the point where half-line from S to P intersects the edge of the bitmap. If that's inside the circle, end. If not, we solve the 

// the triangle with vertices at O, P and the point of intersection with the circle we are looking for X.

// We know the lengths |PO|, |OX| and the angle OPX , because cos(OPX) = cos(180-OPS) = -cos(OPS) = -PS*PO/(|PS|*|PO|)

// then from the law of cosines PX^2 + PO^2 - 2*PX*PO*cos(OPX) = OX^2 so 

// PX = -a + sqrt(a^2 + OX^2 - PO^2) where a = PS*PO/|PS| but we are really looking for d = |PX|/(|PX|+|PS|) = 1/(1+ (|PS|/|PX|) ) and

// |PX|/|PS| = -b + sqrt(b^2 + (OX^2-PO^2)/PS^2) where b=PS*PO/|PS|^2 which can be computed with only one sqrt.

//

// the trick below is the if-less version of the

// 

// t = dx<0.0 ? (u_objD.x-v.x) / (u_objD.x-ux) : (u_objD.x+v.x) / (u_objD.x+ux);

// h = dy<0.0 ? (u_objD.y-v.y) / (u_objD.y-uy) : (u_objD.y+v.y) / (u_objD.y+uy);

// d = min(t,h);      

//

// float d = min(-ps.x/(sign(ps.x)*u_objD.x+p.x),-ps.y/(sign(ps.y)*u_objD.y+p.y))+1.0;

//

// We still have to avoid division by 0 when p.x = +- u_objD.x or p.y = +- u_objD.y (i.e on the edge of the Object)

// We do that by first multiplying the above 'float d' with sign(denominator1*denominator2)^2.

//

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

// return degree of the point as defined by the bitmap rectangle

float degree_bitmap(in vec2 S, in vec2 PS)

  {

  vec2 A = sign(PS)*u_objD.xy + S;

  float B = sign(A.x*A.y);

  return B*B*(1.0 + min(-PS.x/A.x,-PS.y/A.y));

  }

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

// return degree of the point as defined by the Region

// Currently only supports circles; .xy = vector from center of effect to the center of the circle, .z = radius

float degree_region(in vec3 region, in vec2 PS)

  {

  vec2 PO  = PS + region.xy;

  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2

  float ps_sq = dot(PS,PS);

  float DOT  = dot(PS,PO)/ps_sq;

  return max(sign(D),0.0) / (1.0 + 1.0/(sqrt(DOT*DOT+D/ps_sq)-DOT));  // if D<=0 (i.e p is outside the Region) return 0.

  }

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

// return min(degree_bitmap,degree_region). Just like degree_region, currently only supports circles.

float degree(in vec3 region, in vec2 S, in vec2 PS)

  {

  vec2 PO  = PS + region.xy;

  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2

  vec2 A = sign(PS)*u_objD.xy + S;

  float B = sign(A.x*A.y);

  float E = B*B*(1.0 + min(-PS.x/A.x,-PS.y/A.y));

  float ps_sq = dot(PS,PS);

  float DOT  = dot(PS,PO)/ps_sq;

  return max(sign(D),0.0) * min(1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D/ps_sq)-DOT)),E);  // if D<=0 (i.e p is outside the Region) return 0.

  }

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

// Distort effect

// sink effect

// Swirl 

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

// Clamp v.z to (-u_Depth,u_Depth) with the following function:

// define h to be, say, 0.7; let H=u_Depth

//      if v.z < -hH then v.z = (-(1-h)^2 * H^2)/(v.z+(2h-1)H) -H   (function satisfying f(-hH)=-hH, f'(-hH)=1, lim f(x) = -H)

// else if v.z >  hH then v.z = (-(1-h)^2 * H^2)/(v.z-(2h-1)H) +H   (function satisfying f(+hH)=+hH, f'(+hH)=1, lim f(x) = +H)

// else v.z = v.z  

void restrict(inout float v)

  {

  const float h = 0.7;

  float signV = 2.0*max(0.0,sign(v))-1.0;

  float c = ((1.0-h)*(h-1.0)*u_Depth*u_Depth)/(v-signV*(2.0*h-1.0)*u_Depth) +signV*u_Depth;

  float b = max(0.0,sign(abs(v)-h*u_Depth));

  v = b*c+(1.0-b)*v; // Avoid branching: if abs(v)>h*u_Depth, then v=c; otherwise v=v.

  }                

    //switch(vType[i])

    //  {

    //  case DISTORT: distort(3*i,v,n); break;

    //  case DEFORM : deform(3*i,v)   ; break;

    //  case SINK   : sink(3*i,v)     ; break;

    //  case SWIRL  : swirl(3*i,v)    ; break;

    //  }

    else if( vType[i]==DEFORM ) deform(3*i,v);

    else if( vType[i]==SINK   ) sink(3*i,v);

    else if( vType[i]==SWIRL  ) swirl(3*i,v);