Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                          //

//                                                                                          //

// This file is part of Distorted.                                                          //

//                                                                                          //

// Distorted is free software: you can redistribute it and/or modify                        //

// it under the terms of the GNU General Public License as published by                     //

// the Free Software Foundation, either version 2 of the License, or                        //

// (at your option) any later version.                                                      //

//                                                                                          //

// Distorted is distributed in the hope that it will be useful,                             //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            //

// GNU General Public License for more details.                                             //

//                                                                                          //

// You should have received a copy of the GNU General Public License                        // 

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //

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

precision lowp float;

#if __VERSION__ != 100

in vec3 a_Position;                  // Per-vertex position.

in vec3 a_Normal;                    // Per-vertex normal vector.

in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.

out vec3 v_Position;                 //

out vec3 v_Normal;                   //

out vec2 v_TexCoordinate;            //

#else

attribute vec3 a_Position;           // Per-vertex position.

attribute vec3 a_Normal;             // Per-vertex normal vector.

attribute vec2 a_TexCoordinate;      // Per-vertex texture coordinate.

varying vec3 v_Position;             //

varying vec3 v_Normal;               //

varying vec2 v_TexCoordinate;        //

#endif

uniform vec3 u_objD;                 // half of object width x half of object height X half the depth;

                                     // point (0,0,0) is the center of the object

uniform float u_Depth;               // max absolute value of v.z ; beyond that the vertex would be culled by the near or far planes.

                                     // I read OpenGL ES has a built-in uniform variable gl_DepthRange.near = n,

                                     // .far = f, .diff = f-n so maybe u_Depth is redundant

                                     // Update: this struct is only available in fragment shaders

uniform mat4 u_MVPMatrix;            // the combined model/view/projection matrix.

uniform mat4 u_MVMatrix;             // the combined model/view matrix.

#if NUM_VERTEX>0

uniform int vNumEffects;             // total number of vertex effects

uniform int vType[NUM_VERTEX];       // their types.

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

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

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

  vec2 signA = sign(A);                           //

  vec2 signA_SQ = signA*signA;                    // div = PS/A if A!=0, 0 otherwise.

  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));//

  return 1.0-max(div.x,div.y);

  }

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

// Return degree of the point as defined by the Region. Currently only supports circular regions.

//

// Let us first introduce some notation.

// Let 'PS' be the vector from point P (the current vertex) to point S (the center of the effect).

// Let region.xy be the vector from point S to point O (the center point of the region circle)

// Let region.z be the radius of the region circle.

// (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:

//

// If P is outside the circle, return 0.

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

// aka the 'degree' of point P.

//

// We solve the triangle OPX.

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

float degree_region(in vec4 region, in vec2 PS)

  {

  vec2 PO  = PS + region.xy;

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

  if( D<=0.0 ) return 0.0;

  float ps_sq = dot(PS,PS);

  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0

                                                         // Important: if we want to write

                                                         // b = 1/a if a!=0, b=1 otherwise

                                                         // we need to write that as

                                                         // b = 1 / ( a-(sign(a)-1) )

                                                         // [ and NOT 1 / ( a + 1 - sign(a) ) ]

                                                         // because the latter, if 0<a<2^-24,

                                                         // will suffer from round-off error and in this case

                                                         // a + 1.0 = 1.0 !! so 1 / (a+1-sign(a)) = 1/0 !

  float DOT  = dot(PS,PO)*one_over_ps_sq;

  return 1.0 / (1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));

  }

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

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

float degree(in vec4 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

  if( D<=0.0 ) return 0.0;

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

  vec2 signA = sign(A);

  vec2 signA_SQ = signA*signA;

  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));

  float E = 1.0-max(div.x,div.y);

  float ps_sq = dot(PS,PS);

  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0

  float DOT  = dot(PS,PO)*one_over_ps_sq;

  return min(1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT)),E);

  }

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

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

  }

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

// DEFORM EFFECT

//

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

#ifdef DEFORM

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

  {

  const vec2 ONE = vec2(1.0,1.0);

  const float A = 0.5;

  const float B = 0.2;

  const float C = 5.0;

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

  vec2 ps     = center-v.xy;

  vec2 aPS    = abs(ps);

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

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

  vec3 force  = vUniforms[effect].xyz * d;

  vec2 aForce = abs(force.xy);

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

  float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0));

  vec2 Aw = A*maxps;

  vec2 quot = ps / maxps;

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

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

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

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

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

  float mvYhorz = -B * ps.y * aForce.x * (1.0-quot.x) * denomH;      // 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;  // 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;  // impact the horizontal component of the force vector has on horizontal movement

  v.x -= (mvXvert+mvXhorz);

  v.y -= (mvYvert+mvYhorz);

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

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

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

  }

#endif

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

// DISTORT EFFECT

//

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

#ifdef DISTORT

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

  {

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

  vec2 ps = center-v.xy;

  vec3 force = vUniforms[effect].xyz;

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

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

  float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0));          // = 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);                            // thick bubble

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

  v.xy += d*force.xy;

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

  }

#endif

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

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

#ifdef SINK

void sink(in int effect,inout vec3 v)

  {

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

  vec2 ps = center-v.xy;

  float h = vUniforms[effect].x;

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

  v.xy += t*ps;

  }

#endif

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

// PINCH EFFECT

//

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

#ifdef PINCH

void pinch(in int effect,inout vec3 v)

  {

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

  vec2 ps = center-v.xy;

  float h = vUniforms[effect].x;

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

  float angle = vUniforms[effect].y;

  vec2 dir = vec2(sin(angle),-cos(angle));

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

  }

#endif

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

// SWIRL EFFECT

//

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

#ifdef SWIRL

void swirl(in int effect, inout vec3 v)

  {

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

  vec2 PS = center-v.xy;

  vec4 SO = vUniforms[effect+2];

  float d1_circle = degree_region(SO,PS);

  float d1_bitmap = degree_bitmap(center,PS);

  float alpha = vUniforms[effect].x;

  float sinA = sin(alpha);

  float cosA = cos(alpha);

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

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

  float d2 = max(0.0,degree(SG,center,PS2));                   // 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));        // if d2=1 (i.e P=center) we should have P unchanged. How to do it?

  }

#endif

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

// WAVE EFFECT

//

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

#ifdef WAVE

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

  {

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

  float amplitude = vUniforms[effect  ].x;

  float length    = vUniforms[effect  ].y;

  vec2 ps = center - v.xy;

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

  if( deg != 0.0 && length != 0.0 )

    {

    float phase = vUniforms[effect  ].z;

    float alpha = vUniforms[effect  ].w;

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

    float sinA = sin(alpha);

    float cosA = cos(alpha);

    float sinB = sin(beta);

    float cosB = cos(beta);

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

    vec3 dir= vec3(sinB*cosA,cosB*cosA,sinA);

    v += sin(angle)*deg*dir;

    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 abs_z = dir.z <0.0 ? -(sinX*sinY) : (sinX*sinY);

      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,abs_z*fx);

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

      vec3 normal = cross(sx,sy);

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

        {                                   //

        normal.x= 0.0;                      // if( normal.z>0.0 )

        normal.y= 0.0;                      //   {

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

        }                                   //   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.y = (n.y*normal.z + n.z*normal.y);  // ? Because if we do the above, my shitty Nexus4 crashes

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

      }

    }

  }

#endif

#endif  // NUM_VERTEX>0

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

void main()

  {

  vec3 v = 2.0*u_objD*a_Position;

  vec3 n = a_Normal;

#if NUM_VERTEX>0

  int j=0;

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

    {

#ifdef DISTORT

    if( vType[i]==DISTORT) distort(j,v,n); else

#endif

#ifdef DEFORM

    if( vType[i]==DEFORM ) deform (j,v,n); else

#endif

#ifdef SINK

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

#endif

#ifdef PINCH

    if( vType[i]==PINCH  ) pinch  (j,v);   else

#endif

#ifdef SWIRL

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

#endif

#ifdef WAVE

    if( vType[i]==WAVE   ) wave   (j,v,n); else

#endif

    {}

    j+=3;

    }

  restrictZ(v.z);

#endif

  v_Position      = v;

  v_TexCoordinate = a_TexCoordinate;

  v_Normal        = normalize(vec3(u_MVMatrix*vec4(n,0.0)));

  gl_Position     = u_MVPMatrix*vec4(v,1.0);

  }