Distorted Android

public class Distorted 

{

  /**

   * Used in the copy constructor.

   */

  public static final int CLONE_NOTHING = 0x0;

    mFOV = fov;

    if( mProjection.width>0 && mProjection.height>0 )

    }

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

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

/**

 * 

 * @param name one of the constants defined in {@link EffectNames}

 * @return number of Effects aborted.

// Matrix-based effects

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

/**

 * 

 * @param vector 3-dimensional Data which at any given time will return a Static3D

 *               representing the current coordinates of the vector we want to move the Object with.

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

/**

 * 

 * @param scale 3-dimensional Dynamic which at any given time returns a Static3D

 *              representing the current x- , y- and z- scale factors.

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

/**

 *

 * @param scale The factor to scale all 3 dimensions with.

 * @return      ID of the effect added, or -1 if we failed to add one.

      while( mList.size()>0 )

        {

        tmp = mList.remove(0);

        }

      synchronized(mThis)

   * Uniforms: (forceX,forceY,forceZ,regionX,regionY,regionRX,regionRY,centerX,centerY)

   * Unity: (forceX,forceY,forceZ) = (0,0,0)

   */

 /**

   * Deform the whole Object by applying a 2D vector of force to a center point.

   * <p>

   * Uniforms: (macroblockSize,UNUSED,UNUSED,UNUSED, regionX, regionY, regionRX, regionRY)

   * Unity: macroblockSize = 1

   */

 /**

   * Make a given Region (partially) transparent.

   * <p>

  private static final int MAXDIM = 4;  // maximum supported dimension of an effect  

  static

    {

    int len = values().length;

    dimensions = new int[len];

    unities    = new float[MAXDIM*len];

    for(EffectNames name: EffectNames.values())

      {

      dimensions[i] = (name.unity==null ? 0 : name.unity.length);

      switch(dimensions[i])

        {

        case 4: unities[MAXDIM*i+3] = name.unity[3];

    }

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

  static EffectTypes getType(int ordinal)

    {

    }

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

  protected byte mNumEffects;   // number of effects at the moment

  protected long mTotalEffects; // total number of effects ever created

  protected float[] mUniforms;

  protected Dynamic[][] mInter;  // center of the effect

  protected long[] mCurrentDuration;

    if( mMax[mMaxIndex]>0 )

      {

      mUniforms        = new float[numUniforms*mMax[mMaxIndex]];

      mInter           = new Dynamic[3][mMax[mMaxIndex]];

      mCurrentDuration = new long[mMax[mMaxIndex]];

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

      {

        {

        remove(i);

        i--;

    {

    int ret = mNumEffects;

    long removedID;

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

      {

      if( notify )

        {

        removedID = mID[i];

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_REMOVED,

                                          mBitmapID,

                                          null);

        }

    mFreeIndexes[mNumEffects] = removedIndex;

    long removedID = mID[effect];

    for(int j=0; j<mMax[mMaxIndex]; j++)

      {

    for(int j=effect; j<mNumEffects; j++ ) 

      {

      mInter[0][j]        = mInter[0][j+1];

      mInter[1][j]        = mInter[1][j+1];

      mInter[2][j]        = mInter[2][j+1];

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

      EffectMessageSender.newMessage( mListeners.elementAt(i),

                                      EffectMessage.EFFECT_REMOVED,

                                      mBitmapID,

                                      null);

    }

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

    {    

    mCurrentDuration[mNumEffects] = 0;

    int index = mFreeIndexes[mNumEffects];

    mNumEffects++; 

    mTotalEffects++;

    }

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

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_FINISHED,

                                          (mID[i]<<EffectTypes.LENGTH)+EffectTypes.FRAGMENT.type,

                                          mBitmapID,

                                          null);

          {

          remove(i);

          i--;

          continue;

          }

        }

      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain(     mBuf,            4*i  , mCurrentDuration[i]);

    if( mNumEffects>0 )

      {     

      GLES20.glUniform4fv( mUniformsH,2*mNumEffects, mUniforms,0);

      }  

    }

        mUniforms[NUM_UNIFORMS*i+6] = w*mBuf[4*i+2];                                  // in fragment shader rx and ry radii are the last two values of the second vec4

        mUniforms[NUM_UNIFORMS*i+7] = h*mBuf[4*i+3];                                  //

          {

          mUniforms[NUM_UNIFORMS*i+1] = 2.0f*mObjHalfX/mUniforms[NUM_UNIFORMS*i];

          mUniforms[NUM_UNIFORMS*i+2] = 2.0f*mObjHalfY/mUniforms[NUM_UNIFORMS*i];

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_FINISHED,

                                         (mID[i]<<EffectTypes.LENGTH)+EffectTypes.MATRIX.type,

                                          mBitmapID,

                                          null);

          {

          remove(i);

          i--;

          continue;

          }

        }

      if( mInter[1][i]!=null )

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

      {

        {

        x = mUniforms[NUM_UNIFORMS*i+4];

        y = mUniforms[NUM_UNIFORMS*i+5];

        Matrix.rotateM( viewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);

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

        }

        {

        x = mUniforms[NUM_UNIFORMS*i+4];

        y = mUniforms[NUM_UNIFORMS*i+5];

        multiplyByQuat(viewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);

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

        }

        {

        sx = mUniforms[NUM_UNIFORMS*i  ];

        sy = mUniforms[NUM_UNIFORMS*i+1];

        Matrix.translateM(viewMatrix, 0, sx,-sy, sz);   

        }

        {

        sx = mUniforms[NUM_UNIFORMS*i  ];

        sy = mUniforms[NUM_UNIFORMS*i+1];

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

        }

        {

        sx = mUniforms[NUM_UNIFORMS*i  ];

        sy = mUniforms[NUM_UNIFORMS*i+1];

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_FINISHED,

                                         (mID[i]<<EffectTypes.LENGTH)+EffectTypes.VERTEX.type,

                                          mBitmapID,

                                          null);

          {

          remove(i);

          i--;

          continue;

          }

        }

      if( mInter[1][i]!=null )

        mUniforms[NUM_UNIFORMS*i+7] = mUniforms[NUM_UNIFORMS*i+7]-mObjHalfX;

        mUniforms[NUM_UNIFORMS*i+8] =-mUniforms[NUM_UNIFORMS*i+8]+mObjHalfY;

        }

      mCurrentDuration[i] += step;

    if( mNumEffects>0 )

      {     

      GLES20.glUniform3fv( mUniformsH,3*mNumEffects, mUniforms,0);

      }

    }

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

      {      

        {

        d = Math.PI*mUniforms[NUM_UNIFORMS*i]/180;  

        mUniforms[NUM_UNIFORMS*i+1] = (float)Math.sin(d);

 * @param eventType  Type of event that happened.

 * @param effectID   ID of the effect the event happened to. This ID must have been previously returned by one

 *                   of the DistortedObject.{deform,distort,move,...} functions.

 *                   this event happened to. If the Object has been created using a copy constructor

 *                   from another instance of DistortedObject, the ID here will be the one of the original object.

 * @param message    Any message string associated with it. 'Failed' event types have one.

 * @see EffectNames

 */

  }

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

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

/**

* Defines all possible events a class implementing the {@link EffectListener} interface can receive.

*/

/**

 * The effect has been removed. This can happen if:

 * <ul>

 * <li> the interpolation of the effect has finished and the end result is equal to the effect's unity.

 * </ul>    

 */

 * Interpolation of the effect has finished. 

 * <p>

 * If you set up an interpolated effect and set its Dynamic to do 3.5 interpolations of 1000 ms each

 * then you are going to get this message exactly once after 3.5*1000 = 3500 milliseconds when the interpolation 

 * finishes. You will never get this message if you set the effect to go on indefinitely with a call to 

 * <p>  

 * If then the end effect is equal to the effect's unity, then immediately after this message you

 * will also get a EFFECT_REMOVED message.