Distorted Android

   * When creating an instance of a DistortedObject from another instance, clone the PreShader Effects.

  public static final int CLONE_PRESHADER = 0x2;

  // Note: why no 'CLONE_POSTSHADER' constant? The only Postshader effects are the 'save to PNG file'

  // 'save to MP4 file'. Sharing those effects across multiple DistortedObject objects does not make any

  // sense - multiple Objects would then fight to get saved all to the same file.

   * Constant used to represent a PreShader-based effect.

   */

  public static final int TYPE_PRE  = 0x1;

  /**

   * Constant used to represent a PostShader-based effect.

   */

  public static final int TYPE_POST = 0x8;

    EffectListPreShader.getUniforms(mProgramH);

    EffectListPreShader.reset();  // no need to reset PostShader stuff

 * Returns the maximum number of PreShader effects.

 * @return The maximum number of PreShader effects

  public static int getMaxPreShader()

    return EffectListPreShader.getMax();

 * Sets the maximum number of PreShader effects that can be applied to a single DistortedBitmap at one time.

 * @param max new maximum number of simultaneous PreShader Effects. Has to be a non-negative number not greater

  public static boolean setMaxPreShader(int max)

    return EffectListPreShader.setMax(max);

 *        {@link Distorted#CLONE_BITMAP},  {@link Distorted#CLONE_PRESHADER}, {@link Distorted#CLONE_VERTEX},

    static final int TYPE_NUM = 4;

    protected EffectListPreShader  mM;

    protected EffectListFragment   mF;

    protected EffectListVertex     mV;

    protected EffectListPostShader mP;

      if( (flags & Distorted.CLONE_PRESHADER) != 0 )

        mM = new EffectListPreShader(d);

      mP = new EffectListPostShader(d); // PostShader effects are never cloned.

      mP.send();

      mP.abortAll();

      mP            = null;

   *              For example, CLONE_BITMAP | CLONE_PRESHADER.

     mP.addListener(el);

     mP.removeListener(el);

      mP.abortAll();

 * @param mask Bitmask of the types of effects we want to abort, e.g. TYPE_PRE | TYPE_VERT | TYPE_FRAG.

      if( (mask & Distorted.TYPE_PRE ) != 0 ) mM.abortAll();

      if( (mask & Distorted.TYPE_POST) != 0 ) mP.abortAll();

        case Distorted.TYPE_PRE : return mM.removeByID(id>>TYPE_NUM);

        case Distorted.TYPE_POST: return mP.removeByID(id>>TYPE_NUM);

        case Distorted.TYPE_PRE : return mM.removeByType(effectType);

        case Distorted.TYPE_POST: return mP.removeByType(effectType);

        case Distorted.TYPE_PRE : return mM.printByID(id>>TYPE_NUM);

        case Distorted.TYPE_POST: return mP.printByID(id>>TYPE_NUM);

  protected static final int PRESHADER =0;

  protected static final int VERTEX    =1;

  protected static final int FRAGMENT  =2;

    mMax[PRESHADER]= DEFAULT_NUM_EFFECTS;

    if( mListeners==null ) mListeners = new Vector<>(2,2);

    mMax[PRESHADER]= DEFAULT_NUM_EFFECTS;

  public EffectListFragment(DistortedObject obj)

    super(obj,NUM_UNIFORMS,FRAGMENT);

package org.distorted.library;

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

import java.util.Vector;

/**

 * Do NOT base this on EffectList - this is an entirely different animal than the first 3 EffectLists.

 * The Effects in here will be executed after all the shaders have been executed - thus there are no

 * uniforms to send, no real queues to maintain.

 * <p>

 * Only 2 effects here ATM:

 * - save current Surface to a PNG file

 * - save current animation to a .MP4 file

 *

 * In contrast to the other EffectLists, only one instance of each allowed at any given moment - thus

 * this is not even a real EffectList, it is named so only for consistency with the others.

 */

public class EffectListPostShader

  {

  private Vector<EffectListener> mListeners =null;

  private int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added

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

  public EffectListPostShader(DistortedObject obj)

    {

    }

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

  synchronized void send()

    {

    }

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

  synchronized void abortAll()

    {

    }

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

  void addListener(EffectListener el)

    {

    if( mListeners==null ) mListeners = new Vector<>(2,2);

    mListeners.add(el);

    mNumListeners++;

    }

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

  void removeListener(EffectListener el)

    {

    if( mNumListeners>0 )

      {

      mListeners.remove(el);

      mNumListeners--;

      }

    }

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

  synchronized boolean removeByID(long id)

    {

    //....

    return false;

    }

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

  synchronized boolean removeByType(EffectNames effect)

    {

    // ...

    return false;

    }

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

  protected boolean printByID(long id)

    {

    return false;

    }

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

  synchronized long add(EffectNames eln, String filename)

    {

    return 0;

    }

  }

package org.distorted.library;

import android.opengl.GLES20;

import android.opengl.Matrix;

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

class EffectListPreShader extends EffectList

  {   

  private static final int NUM_UNIFORMS = 7; 

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

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

  private static int mBmpDH;      // This is a handle to half a bitmap dimensions

  private static int mDepthH;     // Handle to the max Depth, i.e (farplane-nearplane)/2

  private static int mMVPMatrixH; // pass in the transformation matrix

  private static int mMVMatrixH;  // pass in the modelview matrix.

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

  public EffectListPreShader(DistortedObject obj)

    { 

    super(obj,NUM_UNIFORMS, PRESHADER);

    }

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

  private static void multiplyByQuat(float[] matrix, float X, float Y, float Z, float W)

    {

    float xx= X * X;

    float xy= X * Y;

    float xz= X * Z;

    float xw= X * W;

    float yy= Y * Y;

    float yz= Y * Z;

    float yw= Y * W;

    float zz= Z * Z;

    float zw= Z * W;

    mTmpMatrix[0]  = 1 - 2 * ( yy + zz );

    mTmpMatrix[1]  =     2 * ( xy - zw );

    mTmpMatrix[2]  =     2 * ( xz + yw );

    mTmpMatrix[4]  =     2 * ( xy + zw );

    mTmpMatrix[5]  = 1 - 2 * ( xx + zz );

    mTmpMatrix[6]  =     2 * ( yz - xw );

    mTmpMatrix[8]  =     2 * ( xz - yw );

    mTmpMatrix[9]  =     2 * ( yz + xw );

    mTmpMatrix[10] = 1 - 2 * ( xx + yy );

    mTmpMatrix[3]  = mTmpMatrix[7] = mTmpMatrix[11] = mTmpMatrix[12] = mTmpMatrix[13] = mTmpMatrix[14] = 0;

    mTmpMatrix[15] = 1;

    Matrix.multiplyMM(mMVPMatrix, 0, matrix, 0, mTmpMatrix, 0);  

    for(int j=0; j<16; j++) matrix[j] = mMVPMatrix[j];   

    }

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

// Only max Byte.MAX_VALUE concurrent effects per bitmap.

// If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.

  static boolean setMax(int m)

    {

    if( (mCreated==false && !Distorted.isInitialized()) || m<=mMax[PRESHADER] )

      {

           if( m<0              ) m = 0;

      else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;

      mMax[PRESHADER] = m;

      return true;

      }

    return false;

    }

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

  static int getMax()

    {

    return mMax[PRESHADER];

    }

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

  static void getUniforms(int mProgramH)

    {

    mBmpDH     = GLES20.glGetUniformLocation(mProgramH, "u_bmpD");

    mDepthH    = GLES20.glGetUniformLocation(mProgramH, "u_Depth");

    mMVPMatrixH= GLES20.glGetUniformLocation(mProgramH, "u_MVPMatrix");

    mMVMatrixH = GLES20.glGetUniformLocation(mProgramH, "u_MVMatrix"); 

    }

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

  synchronized void compute(long currTime) 

    {

    if( currTime==mTime ) return;

    if( mTime==0 ) mTime = currTime;

    long step = (currTime-mTime);

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

      {

      if( mInterI[i]==null ) continue;    

      if( mInterP[i]!=null ) 

        {

        mInterP[i].interpolateMain(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i]);

        }

      if( mInterI[i].interpolateMain(mUniforms ,NUM_UNIFORMS*i+3, mCurrentDuration[i], step) )      

        {   

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

          EffectMessageSender.newMessage( mListeners.elementAt(j),

                                          EffectMessage.EFFECT_FINISHED, 

                                         (mID[i]<<DistortedObject.TYPE_NUM)+Distorted.TYPE_PRE,

                                          mType[i], 

                                          mBitmapID); 

        if( EffectNames.isUnity(mType[i], mUniforms, NUM_UNIFORMS*i+3) )

          {  

          remove(i);

          i--;

          continue;

          }

        }

      mCurrentDuration[i] += step;

      }

    mTime = currTime;  

    }  

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

  protected void moveEffect(int index)

    {

    mUniforms[NUM_UNIFORMS*index  ] = mUniforms[NUM_UNIFORMS*(index+1)  ];

    mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];

    mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];

    mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];

    mUniforms[NUM_UNIFORMS*index+4] = mUniforms[NUM_UNIFORMS*(index+1)+4];

    mUniforms[NUM_UNIFORMS*index+5] = mUniforms[NUM_UNIFORMS*(index+1)+5];

    mUniforms[NUM_UNIFORMS*index+6] = mUniforms[NUM_UNIFORMS*(index+1)+6];

    }

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

// here construct the ModelView Matrix

  synchronized void send(float[] viewMatrix, DistortedProjection dp) 

    {

    Matrix.setIdentityM(viewMatrix, 0);

    Matrix.translateM(viewMatrix, 0, -dp.width/2, dp.height/2, -dp.distance);

    float x,y,z, sx,sy,sz=1.0f;

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

      {

      if (mType[i] == EffectNames.ROTATE.ordinal() )

        {

        x = mUniforms[NUM_UNIFORMS*i  ];

        y = mUniforms[NUM_UNIFORMS*i+1];

        z = mUniforms[NUM_UNIFORMS*i+2];

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

        Matrix.rotateM( viewMatrix, 0, mUniforms[NUM_UNIFORMS*i+3], mUniforms[NUM_UNIFORMS*i+4], mUniforms[NUM_UNIFORMS*i+5], mUniforms[NUM_UNIFORMS*i+6]);  

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

        }

      else if(mType[i] == EffectNames.QUATERNION.ordinal() )

        {

        x = mUniforms[NUM_UNIFORMS*i  ];

        y = mUniforms[NUM_UNIFORMS*i+1];

        z = mUniforms[NUM_UNIFORMS*i+2];

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

        multiplyByQuat(viewMatrix, mUniforms[NUM_UNIFORMS*i+3], mUniforms[NUM_UNIFORMS*i+4], mUniforms[NUM_UNIFORMS*i+5], mUniforms[NUM_UNIFORMS*i+6]);

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

        }

      else if(mType[i] == EffectNames.MOVE.ordinal() )

        {

        sx = mUniforms[NUM_UNIFORMS*i+3];   

        sy = mUniforms[NUM_UNIFORMS*i+4];   

        sz = mUniforms[NUM_UNIFORMS*i+5];   

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

        }

      else if(mType[i] == EffectNames.SCALE.ordinal() )

        {

        sx = mUniforms[NUM_UNIFORMS*i+3];   

        sy = mUniforms[NUM_UNIFORMS*i+4];   

        sz = mUniforms[NUM_UNIFORMS*i+5];   

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

        }

      else if(mType[i] == EffectNames.SHEAR.ordinal() )

        {

        x  = mUniforms[NUM_UNIFORMS*i  ];

        y  = mUniforms[NUM_UNIFORMS*i+1];

        z  = mUniforms[NUM_UNIFORMS*i+2];

        sx = mUniforms[NUM_UNIFORMS*i+3];   

        sy = mUniforms[NUM_UNIFORMS*i+4];   

        sz = mUniforms[NUM_UNIFORMS*i+5];   

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

        viewMatrix[4] += sx*viewMatrix[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear. TODO: change this so it is symmetric w respect to all the axis.

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

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

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

        viewMatrix[0] += sy*viewMatrix[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear. TODO: change this so it is symmetric w respect to all the axis.

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

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

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

        // TODO: implement Z-shear.

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

        }

      }

    Matrix.translateM(viewMatrix, 0, mObjHalfX,-mObjHalfY, -mObjHalfZ);

    Matrix.multiplyMM(mMVPMatrix, 0, dp.projectionMatrix, 0, viewMatrix, 0);

    GLES20.glUniform3f( mBmpDH , mObjHalfX, mObjHalfY, mObjHalfZ);

    GLES20.glUniform1f( mDepthH, dp.depth);   

    GLES20.glUniformMatrix4fv(mMVMatrixH , 1, false, viewMatrix, 0);

    GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix, 0);

    }

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

// here construct the ModelView Matrix, but without any effects

  synchronized void sendNoEffects(DistortedProjection dp) 

    {

    Matrix.setIdentityM(mTmpMatrix, 0);

    Matrix.translateM(mTmpMatrix, 0, mObjHalfX-dp.width/2, dp.height/2-mObjHalfY, mObjHalfZ-dp.distance);

    Matrix.multiplyMM(mMVPMatrix, 0, dp.projectionMatrix, 0, mTmpMatrix, 0);

    GLES20.glUniform3f( mBmpDH , mObjHalfX, mObjHalfY, mObjHalfZ);

    GLES20.glUniform1f( mDepthH, dp.depth);  

    GLES20.glUniformMatrix4fv(mMVMatrixH , 1, false, mTmpMatrix, 0);

    GLES20.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix, 0);

    }

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

  synchronized long add(EffectNames eln, Interpolator3D p, Interpolator i)

    {

    if( mMax[PRESHADER]>mNumEffects )

      {

      mInterP[mNumEffects] = p;

      mInterI[mNumEffects] = i;

      return addBase(eln);

      }

    return -1;

    }

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

  synchronized long add(EffectNames eln, float x, float y, float z, Interpolator i)

    {

    if( mMax[PRESHADER]>mNumEffects )

      {

      mInterP[mNumEffects] = null;

      mInterI[mNumEffects] = i;

      mUniforms[NUM_UNIFORMS*mNumEffects  ] = x;

      mUniforms[NUM_UNIFORMS*mNumEffects+1] = y;

      mUniforms[NUM_UNIFORMS*mNumEffects+2] = z;

      return addBase(eln);

      }

    return -1;

    }

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

  synchronized long add(EffectNames eln, float x, float y, float z, Interpolator1D i, float aX, float aY, float aZ)

    {

    if( mMax[PRESHADER]>mNumEffects )

      {

      mInterP[mNumEffects] = null;

      mInterI[mNumEffects] = i;

      mUniforms[NUM_UNIFORMS*mNumEffects  ] = x;

      mUniforms[NUM_UNIFORMS*mNumEffects+1] = y;

      mUniforms[NUM_UNIFORMS*mNumEffects+2] = z;

      mUniforms[NUM_UNIFORMS*mNumEffects+4] = aX;

      mUniforms[NUM_UNIFORMS*mNumEffects+5] = aY;  

      mUniforms[NUM_UNIFORMS*mNumEffects+6] = aZ;  

      return addBase(eln);

      }

    return -1;

    }

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

  synchronized long add(EffectNames eln, Interpolator3D p, Interpolator1D i, float aX, float aY, float aZ)

    {

    if( mMax[PRESHADER]>mNumEffects )

      {

      mInterP[mNumEffects] = p;

      mInterI[mNumEffects] = i;

      mUniforms[NUM_UNIFORMS*mNumEffects+4] = aX;

      mUniforms[NUM_UNIFORMS*mNumEffects+5] = aY;  

      mUniforms[NUM_UNIFORMS*mNumEffects+6] = aZ;  

      return addBase(eln);

      }

    return -1;

    }

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

  synchronized long add(EffectNames eln, float x, float y, float z, float aA, float aX, float aY, float aZ)

    {

    if( mMax[PRESHADER]>mNumEffects )

      {

      mInterP[mNumEffects] = null; 

      mInterI[mNumEffects] = null;

      mUniforms[NUM_UNIFORMS*mNumEffects  ] =  x;

      mUniforms[NUM_UNIFORMS*mNumEffects+1] =  y;  

      mUniforms[NUM_UNIFORMS*mNumEffects+2] =  z;  

      mUniforms[NUM_UNIFORMS*mNumEffects+3] = aA;  

      mUniforms[NUM_UNIFORMS*mNumEffects+4] = aX;

      mUniforms[NUM_UNIFORMS*mNumEffects+5] = aY;  

      mUniforms[NUM_UNIFORMS*mNumEffects+6] = aZ;  

      return addBase(eln);   

      }

    return -1;

    }

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

  }

  public EffectListVertex(DistortedObject obj)

    super(obj,NUM_UNIFORMS,VERTEX);

  ROTATE           ( Distorted.TYPE_PRE ,   new float[] {0.0f}           ),

  QUATERNION       ( Distorted.TYPE_PRE ,   new float[] {0.0f,0.0f,0.0f} ),      // quaternion is a unity iff its axis (x,y,z) is (0,0,0)

  MOVE             ( Distorted.TYPE_PRE ,   new float[] {0.0f,0.0f,0.0f} ),

  SCALE            ( Distorted.TYPE_PRE ,   new float[] {1.0f,1.0f,1.0f} ),

  SHEAR            ( Distorted.TYPE_PRE ,   new float[] {0.0f,0.0f,0.0f} ),

  // add new PreShader effects here...

  SMOOTH_HUE       ( Distorted.TYPE_FRAG,   new float[] {0.0f}           ),

  SAVE_PNG         ( Distorted.TYPE_POST,   null                         ),      // PostShader Effects don't have Unities.

  SAVE_MP4         ( Distorted.TYPE_POST,   null                         );      //

  // add new PostShader effects here...

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

    if( ordinal<DISTORT.ordinal()     ) return Distorted.TYPE_PRE;

    if( ordinal<SAVE_PNG.ordinal()    ) return Distorted.TYPE_FRAG;

    return Distorted.TYPE_POST;