Distorted Android

import android.content.res.Resources;

import org.distorted.library.program.FragmentCompilationException;

import org.distorted.library.program.FragmentUniformsException;

import org.distorted.library.program.LinkingException;

import org.distorted.library.program.VertexCompilationException;

import org.distorted.library.program.VertexUniformsException;

import java.io.InputStream;

  /// DEBUG ONLY /////

  private static DistortedProgram mDebugProgram;

  private static final FloatBuffer mQuadPositions;

  static

    {

    float[] positionData= { -0.5f, -0.5f,  -0.5f, 0.5f,  0.5f,-0.5f,  0.5f, 0.5f };

    mQuadPositions = ByteBuffer.allocateDirect(32).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mQuadPositions.put(positionData).position(0);

    }

  private static int mObjDH;

  private static int mMVPMatrixH;

  /// END DEBUG //////

  static void createProgram(Resources resources)

  throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

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

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

    String mainVertexHeader= ("#version 100\n#define NUM_VERTEX "  + getMaxVertex()+"\n");

    for(EffectNames name: EffectNames.values() )

      {

      if( name.getType()== EffectTypes.VERTEX)

        mainVertexHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");

      }

    String mainFragmentHeader= ("#version 100\n#define NUM_FRAGMENT "  + getMaxFragment()+"\n");

    for(EffectNames name: EffectNames.values() )

      {

      if( name.getType()== EffectTypes.FRAGMENT)

        mainFragmentHeader += ("#define "+name.name()+" "+name.ordinal()+"\n");

      }

    mProgram = new DistortedProgram(mainVertexStream,mainFragmentStream, mainVertexHeader, mainFragmentHeader);

    int mainProgramH = mProgram.getProgramHandle();

    EffectQueueFragment.getUniforms(mainProgramH);

    EffectQueueVertex.getUniforms(mainProgramH);

    EffectQueueMatrix.getUniforms(mainProgramH);

    DistortedTexture.getUniforms(mainProgramH);

    // DEBUG ONLY //////////////////////////////////////

    final InputStream debugVertexStream   = resources.openRawResource(R.raw.test_vertex_shader);

    final InputStream debugFragmentStream = resources.openRawResource(R.raw.test_fragment_shader);

    mDebugProgram = new DistortedProgram(debugVertexStream,debugFragmentStream, "#version 100\n", "#version 100\n");

    int debugProgramH = mDebugProgram.getProgramHandle();

    mObjDH      = GLES20.glGetUniformLocation( debugProgramH, "u_objD");

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

    // END DEBUG  //////////////////////////////////////

// DEBUG ONLY

  private void displayBoundingRect(float halfX, float halfY, float halfZ, DistortedFramebuffer df, float[] mvp, float[] vertices)

    {

    int len  = vertices.length/3;

    int minx = Integer.MAX_VALUE;

    int maxx = Integer.MIN_VALUE;

    int miny = Integer.MAX_VALUE;

    int maxy = Integer.MIN_VALUE;

    int wx,wy;

    float x,y,z, X,Y,W, ndcX,ndcY;

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

      {

      x = 2*halfX*vertices[3*i  ];

      y = 2*halfY*vertices[3*i+1];

      z = 2*halfZ*vertices[3*i+2];

      X = mvp[ 0]*x + mvp[ 4]*y + mvp[ 8]*z + mvp[12];

      Y = mvp[ 1]*x + mvp[ 5]*y + mvp[ 9]*z + mvp[13];

      W = mvp[ 3]*x + mvp[ 7]*y + mvp[11]*z + mvp[15];

      ndcX = X/W;

      ndcY = Y/W;

      wx = (int)(df.mWidth *(ndcX+1)/2);

      wy = (int)(df.mHeight*(ndcY+1)/2);

      if( wx<minx ) minx = wx;

      if( wx>maxx ) maxx = wx;

      if( wy<miny ) miny = wy;

      if( wy>maxy ) maxy = wy;

      }

    mDebugProgram.useProgram();

    df.setAsOutput();

    Matrix.setIdentityM(mTmpMatrix, 0);

    Matrix.translateM(mTmpMatrix, 0, -df.mWidth/2, df.mHeight/2, -df.mDistance);

    Matrix.translateM(mTmpMatrix, 0, minx, -df.mHeight+maxy, 0.0f);

    Matrix.scaleM(mTmpMatrix, 0, (float)(maxx-minx)/(2*halfX), (float)(maxy-miny)/(2*halfY), 1.0f);

    Matrix.translateM(mTmpMatrix, 0, halfX,-halfY, 0);

    Matrix.multiplyMM(mMVPMatrix, 0, df.mProjectionMatrix, 0, mTmpMatrix, 0);

    GLES20.glUniform2f( mObjDH , 2*halfX, 2*halfY);

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

    GLES20.glVertexAttribPointer(mDebugProgram.mAttribute[0], 2, GLES20.GL_FLOAT, false, 0, mQuadPositions);

    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

    }

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

    /// DEBUG ONLY //////

    displayBoundingRect(halfInputH, halfInputW, halfZ, df, mM.getMVP(), mesh.getBoundingVertices() );

    /// END DEBUG ///////