Distorted Android

import android.opengl.Matrix;

import java.nio.Buffer;

  /// DEBUG ONLY /////

  private static DistortedProgram mDebugProgram;

  private static int mDebugObjDH;

  private static int mDebugMVPMatrixH;

  /// END DEBUG //////

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

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

  private EffectQueueMatrix      mM;

  private EffectQueueFragment    mF;

  private EffectQueueVertex      mV;

    String[] feedback = { "v_Position", "v_Normal", "v_ndcPosition" };

    // DEBUG PROGRAM //////////////////////////////////////

    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, Distorted.GLSL_VERSION, Distorted.GLSL_VERSION, Distorted.GLSL);

      android.util.Log.e("EFFECTS", "exception trying to compile DEBUG program: "+e.getMessage());

    int debugProgramH = mDebugProgram.getProgramHandle();

    mDebugObjDH      = GLES30.glGetUniformLocation( debugProgramH, "u_objD");

    mDebugMVPMatrixH = GLES30.glGetUniformLocation( debugProgramH, "u_MVPMatrix");

  @SuppressWarnings("unused")

  private void displayBoundingRect(float halfW, float halfH, DistortedOutputSurface surface, MeshObject mesh)

    int error = GLES30.glGetError();

    if( error != GLES30.GL_NO_ERROR )

      {

      throw new RuntimeException("DrawArrays: glError 0x" + Integer.toHexString(error));

      }

    // mapping the buffer range slows down rendering /////////////////////////

    int size = (MeshObject.POS_DATA_SIZE+MeshObject.NOR_DATA_SIZE+MeshObject.NDC_DATA_SIZE)*mesh.numVertices;

    Buffer mappedBuffer =  GLES30.glMapBufferRange(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 4*size, GLES30.GL_MAP_READ_BIT);

    FloatBuffer fb = ((ByteBuffer) mappedBuffer).order(ByteOrder.nativeOrder()).asFloatBuffer();

    GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER);

    // end of slowdown //////////////////////////////////////////////////////

/*

    String msg = "";

    for(int i=0; i<size; i++) msg += (" "+fb.get(i));

    android.util.Log.d( "Feedback", msg);

*/

    float minx = Integer.MAX_VALUE;

    float maxx = Integer.MIN_VALUE;

    float miny = Integer.MAX_VALUE;

    float maxy = Integer.MIN_VALUE;

    float ndcX,ndcY;

    for(int i=0; i<mesh.numVertices; i++)

      {

      ndcX = fb.get(8*i+6);

      ndcY = fb.get(8*i+7);

      if( ndcX<minx ) minx = ndcX;

      if( ndcX>maxx ) maxx = ndcX;

      if( ndcY<miny ) miny = ndcY;

      if( ndcY>maxy ) maxy = ndcY;

      }

    minx = surface.mWidth *(minx+1)/2;   //

    miny = surface.mHeight*(miny+1)/2;   // transform from NDC to

    maxx = surface.mWidth *(maxx+1)/2;   // window coordinates

    maxy = surface.mHeight*(maxy+1)/2;   //

    mDebugProgram.useProgram();

    Matrix.setIdentityM( mTmpMatrix, 0);

    Matrix.translateM  ( mTmpMatrix, 0, minx-surface.mWidth/2, maxy-surface.mHeight/2, -surface.mDistance);

    Matrix.scaleM      ( mTmpMatrix, 0, (maxx-minx)/(2*halfW), (maxy-miny)/(2*halfH), 1.0f);

    Matrix.translateM  ( mTmpMatrix, 0, halfW,-halfH, 0);

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

    GLES30.glUniform2f(mDebugObjDH, 2*halfW, 2*halfH);

    GLES30.glUniformMatrix4fv(mDebugMVPMatrixH, 1, false, mMVPMatrix , 0);

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

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

    displayBoundingRect(halfW,halfH,surface,mesh);

   static final int NDC_DATA_SIZE= 2;

   static final int TFSIZE  = (POS_DATA_SIZE+NOR_DATA_SIZE+NDC_DATA_SIZE)*BYTES_PER_FLOAT;

out vec2 v_ndcPosition;              // for Transform Feedback only

varying vec2 v_ndcPosition;          // for Transform Feedback only

  vec4 mvpPos;

  mvpPos          = u_MVPMatrix*vec4(v,1.0);

  v_ndcPosition   = vec2(mvpPos.x/mvpPos.w,mvpPos.y/mvpPos.w);

  gl_Position     = mvpPos;

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

// Copyright 2016 Leszek Koltunski                                                          //

//                                                                                          //

// This file is part of Distorted.                                                          //

//                                                                                          //

// Distorted is free software: you can redistribute it and/or modify                        //

// it under the terms of the GNU General Public License as published by                     //

// the Free Software Foundation, either version 2 of the License, or                        //

// (at your option) any later version.                                                      //

//                                                                                          //

// Distorted is distributed in the hope that it will be useful,                             //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            //

// GNU General Public License for more details.                                             //

//                                                                                          //

// You should have received a copy of the GNU General Public License                        //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //

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

precision lowp float;

#if __VERSION__ != 100

out vec4 fragColor;

#define FRAG_COLOR fragColor

#else

#define FRAG_COLOR gl_FragColor

#endif

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

void main()

  {

  FRAG_COLOR = vec4(1.0,0.0,0.0,0.2);

  }

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

// Copyright 2016 Leszek Koltunski                                                          //

//                                                                                          //

// This file is part of Distorted.                                                          //

//                                                                                          //

// Distorted is free software: you can redistribute it and/or modify                        //

// it under the terms of the GNU General Public License as published by                     //

// the Free Software Foundation, either version 2 of the License, or                        //

// (at your option) any later version.                                                      //

//                                                                                          //

// Distorted is distributed in the hope that it will be useful,                             //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            //

// GNU General Public License for more details.                                             //

//                                                                                          //

// You should have received a copy of the GNU General Public License                        // 

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //

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

precision lowp float;

#if __VERSION__ != 100

in vec2 a_Position;        // Per-vertex position information we will pass in.

#else

attribute vec2 a_Position; // Per-vertex position information we will pass in.

#endif

uniform vec2 u_objD;       // object width X object height.

uniform mat4 u_MVPMatrix;  // the combined model/view/projection matrix.

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

void main()

  {

  gl_Position = u_MVPMatrix*vec4( u_objD*a_Position, 0.0, 1.0);

  }