Distorted Android

  public abstract void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index);

  public void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index)

    Matrix.translateM(matrixP, 0, sx, sy, sz);

    Matrix.translateM(matrixV, 0, sx, sy, sz);

  public void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index)

    Matrix.translateM(matrixP, 0, x, y, z);

    multiplyByQuat   (matrixP, qX, qY, qZ, qW);

    Matrix.translateM(matrixP, 0,-x,-y,-z);

    Matrix.translateM(matrixV, 0, x, y, z);

    multiplyByQuat   (matrixV, qX, qY, qZ, qW);

    Matrix.translateM(matrixV, 0,-x,-y,-z);

  public void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index)

    Matrix.translateM(matrixP, 0, x, y, z);

    Matrix.rotateM   (matrixP, 0, angle, axisX, axisY, axisZ);

    Matrix.translateM(matrixP, 0,-x,-y,-z);

    Matrix.translateM(matrixV, 0, x, y, z);

    Matrix.rotateM   (matrixV, 0, angle, axisX, axisY, axisZ);

    Matrix.translateM(matrixV, 0,-x,-y,-z);

 * <p>

 * Here and in Shear we have the whole reason why there are two separate 'P' and 'V' (Point and

 * Vector) matrices - Scale and Shear have to manipulate Points and Normal Vectors differently.

 *

 * Points get multiplied by (sx,sy,sz) - and vectors by (1/sx,1/sy,1/sz) (think about it!) - or

 * better by sx*sy*sz*(1/sx,1/sy,1/sz) to avoid dividing my zero (vectors are normalized after)

  public void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index)

    Matrix.scaleM(matrixP, 0, sx, sy, sz);

    Matrix.scaleM(matrixV, 0, sy*sz, sx*sz, sx*sy);

 * <p>

 * Here and in Shear we have the whole reason why there are two separate 'P' and 'V' (Point and

 * Vector) matrices - Scale and Shear have to manipulate Points and Normal Vectors differently.

  public void apply(float[] matrixP, float[] matrixV, float[] uniforms, int index)

    Matrix.translateM(matrixP, 0, x, y, z);

    matrixP[4] += sx*matrixP[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear.

    matrixP[5] += sx*matrixP[1]; //                        0 1 0 0

    matrixP[6] += sx*matrixP[2]; //                        0 0 1 0

    matrixP[7] += sx*matrixP[3]; //                        0 0 0 1

    matrixP[0] += sy*matrixP[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear.

    matrixP[1] += sy*matrixP[5]; //                        y 1 0 0

    matrixP[2] += sy*matrixP[6]; //                        0 0 1 0

    matrixP[3] += sy*matrixP[7]; //                        0 0 0 1

    matrixP[4] += sz*matrixP[8]; // Multiply viewMatrix by 1 0 0 0 , i.e. Z-shear.

    matrixP[5] += sz*matrixP[9]; //                        0 1 0 0

    matrixP[6] += sz*matrixP[10];//                        0 z 1 0

    matrixP[7] += sz*matrixP[11];//                        0 0 0 1

    Matrix.translateM(matrixP, 0,-x,-y,-z);

    Matrix.translateM(matrixV, 0, x, y, z);

    matrixV[0] -= sx*matrixV[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. vector X-shear.

    matrixV[1] -= sx*matrixV[5]; //                       -x 1 0 0

    matrixV[2] -= sx*matrixV[6]; //                        0 0 1 0

    matrixV[3] -= sx*matrixV[7]; //                        0 0 0 1

    matrixV[4] -= sy*matrixV[0]; // Multiply viewMatrix by 1-y 0 0 , i.e. vector Y-shear.

    matrixV[5] -= sy*matrixV[1]; //                        0 1 0 0

    matrixV[6] -= sy*matrixV[2]; //                        0 0 1 0

    matrixV[7] -= sy*matrixV[3]; //                        0 0 0 1

    matrixV[8] -= sz*matrixV[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. vector Z-shear.

    matrixV[9] -= sz*matrixV[5]; //                        0 1-z 0

    matrixV[10]-= sz*matrixV[6]; //                        0 0 1 0

    matrixV[11]-= sz*matrixV[7]; //                        0 0 0 1

    Matrix.translateM(matrixV, 0,-x,-y,-z);

                          float[] projection, float inflate, int variant )

    ((EffectQueueMatrix  )queues[0]).send(distance, mipmap, projection, variant);

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

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

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

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

    mMVMatrixPH[variant]= GLES30.glGetUniformLocation(mProgramH, "u_MVMatrixP");

    mMVMatrixVH[variant]= GLES30.glGetUniformLocation(mProgramH, "u_MVMatrixV");

  void send(float distance, float mipmap, float[] projection, int variant)

    Matrix.setIdentityM(mModelViewMatrixP, 0);

    Matrix.translateM(mModelViewMatrixP, 0, 0,0, -distance);

    if( mipmap!=1 )

      {

      Matrix.scaleM(mModelViewMatrixP, 0, mipmap, mipmap, mipmap);

      }

    mModelViewMatrixV[ 0] = mModelViewMatrixP[ 0];

    mModelViewMatrixV[ 1] = mModelViewMatrixP[ 1];

    mModelViewMatrixV[ 2] = mModelViewMatrixP[ 2];

    mModelViewMatrixV[ 3] = mModelViewMatrixP[ 3];

    mModelViewMatrixV[ 4] = mModelViewMatrixP[ 4];

    mModelViewMatrixV[ 5] = mModelViewMatrixP[ 5];

    mModelViewMatrixV[ 6] = mModelViewMatrixP[ 6];

    mModelViewMatrixV[ 7] = mModelViewMatrixP[ 7];

    mModelViewMatrixV[ 8] = mModelViewMatrixP[ 8];

    mModelViewMatrixV[ 9] = mModelViewMatrixP[ 9];

    mModelViewMatrixV[10] = mModelViewMatrixP[10];

    mModelViewMatrixV[11] = mModelViewMatrixP[11];

    mModelViewMatrixV[12] = mModelViewMatrixP[12];

    mModelViewMatrixV[13] = mModelViewMatrixP[13];

    mModelViewMatrixV[14] = mModelViewMatrixP[14];

    mModelViewMatrixV[15] = mModelViewMatrixP[15];

    for(int i=mNumEffects-1; i>=0; i--)

      {

      ((MatrixEffect)mEffects[i]).apply(mModelViewMatrixP,mModelViewMatrixV,mUniforms,i);

      }

    Matrix.multiplyMM(mMVPMatrix, 0, projection, 0, mModelViewMatrixP, 0);

    GLES30.glUniformMatrix4fv(mMVMatrixVH[variant], 1, false, mModelViewMatrixV, 0);

    GLES30.glUniformMatrix4fv(mMVMatrixPH[variant], 1, false, mModelViewMatrixP, 0);

    GLES30.glUniformMatrix4fv(mMVPMatrixH[variant], 1, false, mMVPMatrix       , 0);

    matrix.send(distance, mipmap, projection, 2);

  private static int mTransformFeedbackH;

  private static int mNormalProjectionH;

    mTransformFeedbackH= GLES30.glGetUniformLocation( mainProgramH, "u_TransformFeedback");

    mNormalProjectionH = GLES30.glGetUniformLocation( normalProgramH, "u_Projection");

  private static void displayNormals(float[] projection, MeshBase mesh)

    GLES30.glUniform1i(DistortedLibrary.mTransformFeedbackH, 1);

    GLES30.glUniformMatrix4fv(mNormalProjectionH, 1, false, projection, 0);

      EffectQueue.send(queues, distance, mipmap, projection, inflate, 1 );

        EffectQueue.send(queues, distance, mipmap, projection, inflate, 0 );

        displayNormals(projection,mesh);

      EffectQueue.send(queues, distance, mipmap, projection, inflate, 0 );

      if( mesh.getShowNormals() ) displayNormals(projection,mesh);

     float[] matrixP  = new float[16];

     float[] matrixV  = new float[16];

     Matrix.setIdentityM(matrixP,0);

     Matrix.setIdentityM(matrixV,0);

     effect.apply(matrixP, matrixV, uniforms, 0);

         applyMatrixToComponent(matrixP, matrixV, start, end);

   private void applyMatrixToComponent(float[] matrixP, float[] matrixV, int start, int end)

       mVertAttribs1[index+POS_ATTRIB  ] = matrixP[0]*x + matrixP[4]*y + matrixP[ 8]*z + matrixP[12];

       mVertAttribs1[index+POS_ATTRIB+1] = matrixP[1]*x + matrixP[5]*y + matrixP[ 9]*z + matrixP[13];

       mVertAttribs1[index+POS_ATTRIB+2] = matrixP[2]*x + matrixP[6]*y + matrixP[10]*z + matrixP[14];

       mVertAttribs1[index+NOR_ATTRIB  ] = matrixV[0]*x + matrixV[4]*y + matrixV[ 8]*z;

       mVertAttribs1[index+NOR_ATTRIB+1] = matrixV[1]*x + matrixV[5]*y + matrixV[ 9]*z;

       mVertAttribs1[index+NOR_ATTRIB+2] = matrixV[2]*x + matrixV[6]*y + matrixV[10]*z;

       x = mVertAttribs1[index+NOR_ATTRIB  ];

       y = mVertAttribs1[index+NOR_ATTRIB+1];

       z = mVertAttribs1[index+NOR_ATTRIB+2];

       float len1 = (float)Math.sqrt(x*x + y*y + z*z);

       if( len1>0.0f )

         {

         mVertAttribs1[index+NOR_ATTRIB  ] /= len1;

         mVertAttribs1[index+NOR_ATTRIB+1] /= len1;

         mVertAttribs1[index+NOR_ATTRIB+2] /= len1;

         }

       mVertAttribs1[index+INF_ATTRIB  ] = matrixV[0]*x + matrixV[4]*y + matrixV[ 8]*z;

       mVertAttribs1[index+INF_ATTRIB+1] = matrixV[1]*x + matrixV[5]*y + matrixV[ 9]*z;

       mVertAttribs1[index+INF_ATTRIB+2] = matrixV[2]*x + matrixV[6]*y + matrixV[10]*z;

       x = mVertAttribs1[index+INF_ATTRIB  ];

       y = mVertAttribs1[index+INF_ATTRIB+1];

       z = mVertAttribs1[index+INF_ATTRIB+2];

       float len2 = (float)Math.sqrt(x*x + y*y + z*z);

       if( len2>0.0f )

         {

         mVertAttribs1[index+INF_ATTRIB  ] /= len2;

         mVertAttribs1[index+INF_ATTRIB+1] /= len2;

         mVertAttribs1[index+INF_ATTRIB+2] /= len2;

         }

uniform mat4 u_MVMatrixP;            // the combined model/view matrix. (for points)

uniform mat4 u_MVMatrixV;            // the combined model/view matrix. (for vectors)

                                     // which need to work differently on points and vectors

uniform int u_TransformFeedback;     // are we doing the transform feedback now?

  v_Position   = v;

  v_endPosition= n;

  v_Inflate    = inf;

  if( u_TransformFeedback == 1 )

    {

    vec4 tmp1 =  u_MVMatrixP * vec4(v,1.0);

    vec4 tmp2 =  normalize(u_MVMatrixV * vec4(n,0.0));

    v_Position    = vec3(tmp1);

    v_endPosition = vec3(tmp1+100.0*tmp2);

    }

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

uniform mat4 u_Projection;

  gl_Position = u_Projection * vec4(a_Position, 1.0);