Distorted Android

  DEFORM           ( EffectType.VERTEX  ,   new float[] {0.0f,0.0f,0.0f} , 3, 4,     3    , VertexEffectDeform.class       ),

      + "vec3 maxps  = u_Bounding + abs(center);                             \n"

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

  public VertexEffectDeform(Data3D vector, Data3D center, Data4D region)

  public VertexEffectDeform(Data3D vector, Data3D center)

        "vec3 center = vUniforms[effect+1].yzw;                        \n"

      + "vec3 ps = center-v;                                           \n"

      + "float d = degree(region,center,ps);                           \n"

        "vec3 center = vUniforms[effect+1].yzw;              \n"

      + "vec3 ps = center-v;                                 \n"

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

        "vec3 center = vUniforms[effect+1].yzw;            \n"

      + "vec3 ps = center-v;                               \n"

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

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

      + "float d1_object = degree_object(center,PS);                        \n"

      + "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

      + "v.xy += min(d1_circle,d1_object)*(PS.xy - PS2.xy/(1.0-d2));        \n" // if d2=1 (i.e P=center) we should have P unchanged. How to do it?

        "vec3 center     = vUniforms[effect+1].yzw; \n"

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

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

      + "vec3 ps = center - v; \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"

      +   "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 thing 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 Nexus4 crashes

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

      +     "} \n"

  private static int[] mBoundingH  = new int[MAIN_VARIANTS];

  private static float[] mTmpMatrix = new float[16];

  private static float[] mTmpResult = new float[4];

  private static float[] mTmpPoint  = new float[4];

  private static float mMinX,mMaxX,mMinY,mMaxY;

    mBoundingH[variant] = GLES30.glGetUniformLocation(mProgramH, "u_Bounding");

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

  private void magnifyDir()

    {

    Matrix.multiplyMV(mTmpResult,0,mTmpMatrix,0,mTmpPoint,0);

    float nx = mTmpResult[0]/mTmpResult[3];

    float ny = mTmpResult[1]/mTmpResult[3];

    if( nx<mMinX ) mMinX = nx;

    if( nx>mMaxX ) mMaxX = nx;

    if( ny<mMinY ) mMinY = ny;

    if( ny>mMaxY ) mMaxY = ny;

    }

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

// return a float which describes how much larger an object must be so that it appears to be (about)

// 'marginInPixels' pixels larger in each direction. Used in Postprocessing.

  float magnify(float[] projection, int width, int height, float mipmap, MeshBase mesh, float marginInPixels)

    {

    mMinX = Integer.MAX_VALUE;

    mMaxX = Integer.MIN_VALUE;

    mMinY = Integer.MAX_VALUE;

    mMaxY = Integer.MIN_VALUE;

    mTmpPoint[3] = 1.0f;

    Matrix.multiplyMM(mTmpMatrix, 0, projection, 0, mModelViewMatrix, 0);

    float halfX = mesh.getBoundingX();

    float halfY = mesh.getBoundingY();

    float halfZ = mesh.getBoundingZ();

    mTmpPoint[0] = +halfX; mTmpPoint[1] = +halfY; mTmpPoint[2] = +halfZ; magnifyDir();

    mTmpPoint[0] = +halfX; mTmpPoint[1] = +halfY; mTmpPoint[2] = -halfZ; magnifyDir();

    mTmpPoint[0] = +halfX; mTmpPoint[1] = -halfY; mTmpPoint[2] = +halfZ; magnifyDir();

    mTmpPoint[0] = +halfX; mTmpPoint[1] = -halfY; mTmpPoint[2] = -halfZ; magnifyDir();

    mTmpPoint[0] = -halfX; mTmpPoint[1] = +halfY; mTmpPoint[2] = +halfZ; magnifyDir();

    mTmpPoint[0] = -halfX; mTmpPoint[1] = +halfY; mTmpPoint[2] = -halfZ; magnifyDir();

    mTmpPoint[0] = -halfX; mTmpPoint[1] = -halfY; mTmpPoint[2] = +halfZ; magnifyDir();

    mTmpPoint[0] = -halfX; mTmpPoint[1] = -halfY; mTmpPoint[2] = -halfZ; magnifyDir();

    float xLenInPixels = width *(mMaxX-mMinX)/2;

    float yLenInPixels = height*(mMaxY-mMinY)/2;

    // already margin / avg(xLen,yLen) is the size of the halo.

    // Here we need a bit more because we are marking not only the halo, but a little bit around

    // it as well so that the (blur for example) will be smooth on the edges. Thus the 2.0f.

    // ( 4.0 because there is an extra 2.0 from the avg(xLen,yLen) )

    //

    // mMipmap ( 1.0, 0.5, 0.25, 0.125 ) - we need to make the size of the halo independent

    // of postprocessing effect quality.

    return mipmap*4.0f*marginInPixels/( xLenInPixels+yLenInPixels );

    }

    GLES30.glUniform3f( mBoundingH[variant] , mesh.getBoundingX(), mesh.getBoundingY(), mesh.getBoundingZ());

    float inflate=0.0f;

    if( mHalo!=0.0f )

      {

      inflate = matrix.magnify(projection, width, height, mipmap, mesh, mHalo);

      }

    vertex.send(inflate,2);

   private float mBoundingX, mBoundingY, mBoundingZ;

   MeshBase(float bx, float by, float bz)

     mBoundingX = bx/2;

     mBoundingY = by/2;

     mBoundingZ = bz/2;

     mBoundingX = original.mBoundingX;

     mBoundingY = original.mBoundingY;

     mBoundingZ = original.mBoundingZ;

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

   void setBounding(float bx, float by, float bz)

     {

     mBoundingX = bx/2;

     mBoundingY = by/2;

     mBoundingZ = bz/2;

     }

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

/**

 * Each mesh has its 'bounding box' - return half of its X-length.

 * <p>

 * In case of all 'simple' Meshes, the bounding box is always 1x1x1 (Sphere, Cubes) or 1x1x0

 * (Rectangles, Triangles, Quad - i.e. all 'flat' Meshes). But this can be something else in case of

 * MeshComponent.

 */

   public float getBoundingX()

    {

    return mBoundingX*mStretchX;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Y-length.

 */

   public float getBoundingY()

    {

    return mBoundingY*mStretchY;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Z-length.

 */

   public float getBoundingZ()

    {

    return mBoundingZ*mStretchZ;

    }

   super(1,1,1);

   super(1,1,1);

   super(1,1,1);

   super(1,1,1);

    super(1,1,1);

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

/**

 * Sets the lengths of the bounding box.

 * <p>

 * The 'bounding box' is an imaginary rectanguloid of size (bx,by,bz) inside of which this Mesh

 * fits tightly.

 * 'Normal' 3D meshes (e.g. Sphere) have this equal to 1,1,1. 'Normal' flat meshes (e.g. Quad) -

 * to 1,1,0. Here however we are joining several, probably already changed by MatrixEffects,

 * Meshes together. If the result fits into the standard 1,1,1 (recommended!) - we don't need to

 * call this function at all.

 *

 * @param bx x-length of the bounding box

 * @param by y-length of the bounding box

 * @param bz z-length of the bounding box

 */

   public void setBounding(float bx, float by, float bz)

     {

     super.setBounding(bx,by,bz);

     }

    super(1,1,0);

    super(1,1,0);

    super(1,1,1);

     super(1,1,0);

uniform vec3 u_Bounding;             // MeshBase.mBounding{X,Y,Z}

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

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

//

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

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

// d = min(t,h);

//

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

//

// We still have to avoid division by 0 when p.x = +- u_Bounding.x or p.y = +- u_Bounding.y (i.e

// on the edge of the Object).

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

//

// 2019-01-09: make this 3D. The trick: we want only the EDGES of the cuboid to stay constant.

// the interiors of the Faces move! Thus, we want the MIDDLE of the PS/(sign(PS)*u_Bounding+S) !

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

// return degree of the point as defined by the cuboid (u_Bounding.x X u_Bounding.y X u_Bounding.z)

float degree_object(in vec3 S, in vec3 PS)

  {

  vec3 ONE = vec3(1.0,1.0,1.0);

  vec3 A = sign(PS)*u_Bounding + S;

  vec3 signA = sign(A);                      //

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

  vec3 div = signA_SQ*PS/(A-(ONE-signA_SQ)); //

  vec3 ret = sign(u_Bounding)-div;

  float d1= ret.x-ret.y;

  float d2= ret.y-ret.z;

  float d3= ret.x-ret.z;

  if( d1*d2>0.0 ) return ret.y;             //

  if( d1*d3>0.0 ) return ret.z;             // return 1-middle(div.x,div.y,div.z)

  return ret.x;                             // (unless size of object is 0 then 0-middle)

  }

float degree_region(in vec4 region, in vec3 PS)

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

// return min(degree_object,degree_region). Just like degree_region, currently only supports spheres.

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

  {

  vec3 PO  = PS + region.xyz;

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

  if( D<=0.0 ) return 0.0;

  vec3 A = sign(PS)*u_Bounding + S;

  vec3 signA = sign(A);

  vec3 signA_SQ = signA*signA;

  vec3 div = signA_SQ*PS/(A-(vec3(1.0,1.0,1.0)-signA_SQ));

  vec3 ret = sign(u_Bounding)-div;            // if object is flat, make ret.z 0

  float d1= ret.x-ret.y;

  float d2= ret.y-ret.z;

  float d3= ret.x-ret.z;

  float degree_object;

       if( d1*d2>0.0 ) degree_object= ret.y;  //

  else if( d1*d3>0.0 ) degree_object= ret.z;  // middle of the ret.{x,y,z} triple

  else                 degree_object= ret.x;  //

  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;

  float degree_region = 1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));

  return min(degree_region,degree_object);

  }