Distorted Android

// Let us first introduce some notation.

// (This all should work regardless if S is inside or outside of the circle).

//

// Then, the degree of a point with respect to a given (circular!) Region is defined by:

// Otherwise, let X be the point where the halfline SP meets the region circle - then return |PX|/||SX|,

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

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

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

//

// 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 Y (where angles X,Y are defined above) along vector (1,0,0).

// 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 (***).

    float angle= 1.578*(-ps.x*cosB-ps.y*sinB) / length;  // -ps.x and -ps.y because the 'ps=center-v.xy' inverts the XY axis!

    if( n.z != 0.0 )

      {

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

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

      float sinX = ( sqrtY==0.0 ? 0.0 : dir.z / sqrtY);

      float cosX = ( sqrtY==0.0 ? 1.0 : dir.x / sqrtY);

      float sinY = ( sqrtX==0.0 ? 0.0 : dir.z / sqrtX);

      float cosY = ( sqrtX==0.0 ? 1.0 : dir.y / sqrtX);

      float tmp = 1.578*cos(angle)*deg/length;

      float fx = cosB*tmp;

      float fy = sinB*tmp;

      vec3 sx = vec3 (1.0+cosX*fx,cosY*sinX*fx,sinY*sinX*fx);

      vec3 sy = vec3 (cosX*sinY*fy,1.0+cosY*fy,sinX*sinY*fy);

      vec3 normal = cross(sx,sy);

      if( normal.z > 0.0 )

        {

        n.xy += (n.z/normal.z)*vec2(normal.x,normal.y);

        }