Distorted Android

  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];

  private final static int[]   mUnityDim = new int[NUM_EFFECTS];

  static boolean[] mEnabled = new boolean[NUM_EFFECTS];

  static

    mCenterDim = name.getCenterDimension();

    mRegionDim = name.getRegionDimension();

    int n = name.ordinal();

    float[] u = name.getUnity();

    int l = u.length;

    return null;

    }

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

// PUBLIC API

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

    {

    return

          "{\n" +

           code +"\n" +

          "}\n" +

    {

    return mNumEnabled;

    }

  }

  long[] mCurrentDuration;

  Effect[] mEffects;

  int[] mName;

  long mTime;

  private static int[] mMax = new int[EffectType.LENGTH];

        mCurrentDuration = new long[max];

        mEffects         = new Effect[max];

        mName            = new int[max];

        }

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

        mEffects[i]         = source.mEffects[i];

        mCurrentDuration[i] = source.mCurrentDuration[i];

        mName[i]            = source.mName[i];

        }

      }

    }

      mEffects[j]         = mEffects[j+1];

      mCurrentDuration[j] = mCurrentDuration[j+1];

      mName[j]            = mName[j+1];

      }

    mEffects[mNumEffects] = null;

                       mCurrentDuration = new long[max];

                       mEffects         = new Effect[max];

                       mName            = new int[max];

                       }

                     mCreated = true;

                         mCurrentDuration[mNumEffects] = 0;

                         mEffects[mNumEffects] = job.effect;

                         mName[mNumEffects] = job.effect.getName().ordinal();

                         mNumEffects++;

                         changed = true;

                           mCurrentDuration[j] = mCurrentDuration[j-1];

                           mEffects[j]         = mEffects[j-1];

                           mName[j]            = mName[j-1];

                           }

                         mCurrentDuration[position] = 0;

                         mEffects[position] = job.effect;

                         mName[position] = job.effect.getName().ordinal();

                         mNumEffects++;

                         changed = true;

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

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

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

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

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

    mNumEffectsH[variant]= GLES30.glGetUniformLocation( mProgramH, "vNumEffects");

    mNameH[variant]      = GLES30.glGetUniformLocation( mProgramH, "vName");

    mUniformsH[variant]  = GLES30.glGetUniformLocation( mProgramH, "vUniforms");

    mInflateH[variant]   = GLES30.glGetUniformLocation( mProgramH, "u_Inflate");

    }

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

      {

      mCurrentDuration[i] += step;

      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )

        {

    if( mNumEffects>0 )

      {

      GLES30.glUniform1iv( mNameH[variant]    ,                 mNumEffects, mName    ,0);

      GLES30.glUniform4fv( mUniformsH[variant],(NUM_UNIFORMS/4)*mNumEffects, mUniforms,0);

      }

    }

 */

public abstract class MeshBase

   {

   // sizes of attributes of an individual vertex.

   private static final int POS_DATA_SIZE= 3; // vertex coordinates: x,y,z

   private static final int NOR_DATA_SIZE= 3; // normal vector: x,y,z

   private static final int INF_DATA_SIZE= 3; // 'inflate' vector: x,y,z

   private static final int TEX_DATA_SIZE= 2; // texture coordinates: s,t

   static final int POS_ATTRIB   = 0;

   static final int NOR_ATTRIB   = POS_DATA_SIZE;

   static final int INF_ATTRIB   = POS_DATA_SIZE + NOR_DATA_SIZE;

   static final int TEX_ATTRIB   = 0;

   static final int VERT1_ATTRIBS= POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;  // number of attributes of a vertex (the part changed by preapply)

   static final int TRAN_ATTRIBS = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;  // number of attributes of a transform feedback vertex

   private static final int BYTES_PER_FLOAT = 4;

   private static final int OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_INF = INF_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT;

   private static final int TRAN_SIZE  = TRAN_ATTRIBS*BYTES_PER_FLOAT;

   private static final int VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT;

   private static final int VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT;

     int size = original.mComponent.size();

     mComponent = new ArrayList<>();

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

       {

       Component comp = new Component(original.mComponent.get(i));

     GLES30.glVertexAttribPointer(program.mAttribute[2], INF_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_INF);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index2 );

     GLES30.glVertexAttribPointer(program.mAttribute[3], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_TEX);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0);

     }

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

/**

 */

       attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[BACK]  + (1.0f-y) * mTexMappingH[BACK];

       }

     currVert++;

     }

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[TOP] +       x  * mTexMappingW[TOP];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[TOP] + (0.5f-z) * mTexMappingH[TOP];

                   break;

       case SOUTH: row = curr.row+1;

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[BOTTOM] +       x  * mTexMappingW[BOTTOM];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[BOTTOM] + (0.5f-z) * mTexMappingH[BOTTOM];

                   break;

       case WEST : row = (back  ? (curr.row+1):(curr.row));

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[LEFT] + (0.5f-z) * mTexMappingW[LEFT];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[LEFT] + (1.0f-y) * mTexMappingH[LEFT];

                   break;

       case EAST : row = (back  ? (curr.row):(curr.row+1));

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[RIGHT] + (0.5f-z) * mTexMappingW[RIGHT];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[RIGHT] + (1.0f-y) * mTexMappingH[RIGHT];

                   break;

       }

     attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB  ];

     attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB+1];

     currVert++;

     }

    attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB  ] = x;

    attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB+1] = 1.0f-y;

    }

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

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = x;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-y;

     return vertex+1;

     }

       attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB  ];

       attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB+1];

       vertex++;

       }

  private static final int NUMFACES = 16;

  private static final double P = Math.PI;

  // fashion. Each face is a triangle, with 2 vertices on the same latitude.

  // Single row is (longitude of V1, longitude of V2, (common) latitude of V1 and V2, latitude of V3)

  // longitude of V3 is simply midpoint of V1 and V2 so we don't have to specify it here.

      attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB  ];

      attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB+1];

      currentVert++;

      }

    attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB  ] = (float)texX;

    attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = (float)texY;

    currentVert++;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = x;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = y;

     return vertex+1;

     }

in vec3 a_Inflate;                   // This vector describes the direction this vertex needs to go when we 'inflate' the whole mesh.

                                     // If the mesh is locally smooth, this is equal to the normal vector. Otherwise (on sharp edges) - no.

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

out vec3 v_Position;                 //

out vec3 v_endPosition;              // for Transform Feedback only

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,

                                     // second vec4: first float - cache, next 3: Center, the third -  the Region.

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

// HELPER FUNCTIONS