Distorted Android

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;                 // A constant representing the combined model/view/projection matrix.      		       

uniform mat4 u_MVMatrix;                  // A constant representing the combined model/view matrix.       		

attribute vec3 a_Position;                // Per-vertex position information we will pass in.   				

attribute vec3 a_Normal;                  // Per-vertex normal information we will pass in.

attribute vec2 a_TexCoordinate;           // Per-vertex texture coordinate information we will pass in. 		

varying vec3 v_Position;                  //      		

varying vec3 v_Normal;                    //

varying vec2 v_TexCoordinate;             //  		

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.

// If the point of application (Sx,Sy) is on the edge of the Object, then:

//    Suppose the upper-left corner of the Object rectangle is point L, upper-right - R, force vector V is applied to point M on the upper edge,

//    width of the Object = w, height = h, |LM| = Wl, |MR| = Wr, force vector V=(Vx,Vy). Also let H = h/(h+Vy)

//    Now define points Fl and Fr, the points L and R will be moved to under force V, with Fl(y)=L'(y) and Fr(y)=R'(y) and |VrFr|/|VrR'| = |VlFl|/|VlL'| = H

//    Lets now denote M+vec(V) = M'. The line segment LMR gets distorted to the curve Fl-M'-Fr. Let's now arbitrarilly decide that:

//    Now if Fl=(flx,fly) , M'=(mx,my) , Fr=(frx,fry); direction vector at Fl is (vx,vy) and at M' is (+c,0) where +c is some positive constant, then 

//    the parametric equations of the Fl--->M' section of the curve (which has to satisfy (X(0),Y(0)) = Fl, (X(1),Y(1))=M', (X'(0),Y'(0)) = (vx,vy), (X'(1),Y'(1)) = (+c,0)) is

//    Here we have to have X'(1) = 2(mx-flx)-vx which is positive <==> vx<2(mx-flx). We also have to have vy<2(my-fly) so that Y'(t)>0 (this is a must otherwise we have local loops!) 

//    Similarly for the Fr--->M' part of the curve we have the same equation except for the fact that this time we have to have X'(1)<0 so now we have to have vx>2(mx-flx).

//    If we are stretching the left or right edge of the bitmap then the only difference is that we have to have (X'(1),Y'(1)) = (0,+-c) with + or - c depending on which part of the curve

//    Now point (x,u_objD.x) on the top edge will move by vector (X(t),Y(t)) where those functions are given by (*) and

//    t =  x < dSx ? (u_objD.x+x)/(u_objD.x+dSx) : (u_objD.x-x)/(u_objD.x-dSx)    (this is 'vec2 time' below in the code)