Distorted Android

import android.content.res.Resources;

   /**

   * When creating an instance of a DistortedEffects from another instance, clone the PostProcess Effects.

   * <p>

   * This way we can have two different DistortedEffects sharing the POSTPROCESS queue.

   */

  public static final int CLONE_POSTPROCESS= 0x10;

  public static final int CLONE_CHILDREN= 0x20;

  static int[] mPostProgramAttributes;

  static int mainProgramH, postProgramH;

    {

    final Resources resources = context.getResources();

    final InputStream mainVertexStream   = resources.openRawResource(R.raw.main_vertex_shader);

    final InputStream mainFragmentStream = resources.openRawResource(R.raw.main_fragment_shader);

    DistortedProgram mainProgram = new DistortedProgram(mainVertexStream,mainFragmentStream);

    mainProgramH = mainProgram.getProgramHandle();

    GLES20.glUseProgram(mainProgramH);

    EffectQueueFragment.getUniforms(mainProgramH);

    EffectQueueVertex.getUniforms(mainProgramH);

    EffectQueueMatrix.getUniforms(mainProgramH);

    DistortedTexture.getUniforms(mainProgramH);

    final InputStream postVertexStream   = resources.openRawResource(R.raw.post_vertex_shader);

    final InputStream postFragmentStream = resources.openRawResource(R.raw.post_fragment_shader);

    DistortedProgram postProgram = new DistortedProgram(postVertexStream,postFragmentStream);

    postProgramH = postProgram.getProgramHandle();

    GLES20.glUseProgram(postProgramH);

    postProgram.bindAndEnableAttributes();

    mPostProgramAttributes = postProgram.getAttributes();

    EffectQueuePostprocess.getUniforms(postProgramH);

  private EffectQueueMatrix      mM;

  private EffectQueueFragment    mF;

  private EffectQueueVertex      mV;

  private EffectQueuePostprocess mP;

  private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;

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

      {

      mP = d.mP;

      postprocessCloned = true;

      }

    else

      {

      mP = new EffectQueuePostprocess(mID);

      postprocessCloned = false;

      }

    mP.compute(currTime);

    float halfZ = halfInputW*mesh.zFactor;

    GLES20.glUseProgram(Distorted.mainProgramH);

    if( mP.mNumEffects==0 )

      {

      GLES20.glViewport(0, 0, df.mWidth, df.mHeight);

      mM.send(df,halfInputW,halfInputH,halfZ);

      mV.send(halfInputW,halfInputH,halfZ);

      mF.send(halfInputW,halfInputH);

      mesh.draw();

      }

    else

      {

      DistortedFramebuffer fbo = null;

      // TODO : set this as output

      // render to the FBO just like above

      /*

      GLES20.glViewport(0, 0, fbo.mWidth, fbo.mHeight);

      mM.send(fbo,halfInputW,halfInputH,halfZ);

      mV.send(halfInputW,halfInputH,halfZ);

      mF.send(halfInputW,halfInputH);

      mesh.draw();

      */

      GLES20.glUseProgram(Distorted.postProgramH);

      // apply postprocess effects

      mP.postprocess(fbo,df);

      }

  static void drawNoEffectsPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedFramebuffer df)

    EffectQueueMatrix.sendZero(df,halfInputW,halfInputH,halfInputW*mesh.zFactor);

    EffectQueueVertex.sendZero();

    EffectQueueFragment.sendZero();

    EffectQueuePostprocess.sendZero(2*halfInputW,2*halfInputH);

    if( !matrixCloned     ) mM.abortAll(false);

    if( !vertexCloned     ) mV.abortAll(false);

    if( !fragmentCloned   ) mF.abortAll(false);

    if( !postprocessCloned) mP.abortAll(false);

    mP = null;

    mP.registerForMessages(el);

    mP.deregisterForMessages(el);

      return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true) + mP.abortAll(true);

      case MATRIX     : return mM.abortAll(true);

      case VERTEX     : return mV.abortAll(true);

      case FRAGMENT   : return mF.abortAll(true);

      case POSTPROCESS: return mP.abortAll(true);

      default         : return 0;

    if( type==EffectTypes.MATRIX.type      ) return mM.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.VERTEX.type      ) return mV.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type    ) return mF.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.POSTPROCESS.type ) return mP.removeByID(id>>EffectTypes.LENGTH);

      case MATRIX     : return mM.removeByType(name);

      case VERTEX     : return mV.removeByType(name);

      case FRAGMENT   : return mF.removeByType(name);

      case POSTPROCESS: return mP.removeByType(name);

      default         : return 0;

    if( type==EffectTypes.MATRIX.type      )  return mM.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.VERTEX.type      )  return mV.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type    )  return mF.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.POSTPROCESS.type )  return mP.printByID(id>>EffectTypes.LENGTH);

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

// Postprocess-based effects

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

/**

 * Blur the object.

 *

 * @param radius The 'strength' if the effect, in pixels. 0 = no blur, 10 = when blurring a given pixel,

 *               take into account 10 pixels in each direction.

 * @param center 2-dimensional Data that, at any given time, returns the Center of the Effect.

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

 */

  public long blur(Data1D radius, Data2D center)

    {

    return mP.add(EffectNames.BLUR, radius, center);

    }

  private static synchronized void deleteAllMarked()

          DistortedEffects.drawNoEffectsPriv(mTexture.mHalfX, mTexture.mHalfY, mMesh, mData.mFBO);

  synchronized static void sendZero()

  synchronized static void sendZero(DistortedFramebuffer df, float halfX, float halfY, float halfZ)

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

  void postprocess(DistortedFramebuffer input, DistortedFramebuffer output)

    {

    // TODO

    }

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

  synchronized static void sendZero(float objX, float objY)

    {

    GLES20.glUniform1i( mNumEffectsH, 0);

    GLES20.glUniform2f( mObjDH , objX, objY);

    }

  synchronized static void sendZero()

#define NUM_POSTPROCESS 3

#define BLUR 0

precision lowp float;

varying vec2 v_TexCoordinate;

uniform int pNumEffects;                   // total number of postprocessing effects

void blur(out vec4 pixel)

  pixel = vec4(0.0);

  for (float x = -4.0; x <= 4.0; x+=1.0)

    for (float y = -4.0; y <= 4.0; y+=1.0)

      {

      pixel += texture2D( u_Texture, vec2(v_TexCoordinate.x + x * blurSizeH, v_TexCoordinate.y + y * blurSizeV) ) / 81.0;

      }

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