Distorted Android

  static final String glslVersion="#version 300 es\n";

    String mainVertHeader= Distorted.glslVersion;

    String mainFragHeader= Distorted.glslVersion;

    String blitVertHeader= (Distorted.glslVersion + "#define NUM_VERTEX 0\n"  );

    String blitFragHeader= (Distorted.glslVersion + "#define NUM_FRAGMENT 0\n");

    try

      {

      mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream,blitVertHeader,blitFragHeader);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    try

      {

      mDebugProgram = new DistortedProgram(debugVertexStream,debugFragmentStream, Distorted.glslVersion, Distorted.glslVersion);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

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

// For setting the Depth texture as input to fragment shaders that merge many planes. (currently: blur2)

  boolean setAsDepth()

    {

    if( mDepthH[0]>0 )

      {

      GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

      GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mDepthH[0]);

      return true;

      }

    return false;

    }

      GLES30.glActiveTexture(GLES30.GL_TEXTURE0);

      GLES30.glActiveTexture(GLES30.GL_TEXTURE0);

  private static DistortedProgram mBlur1Program, mBlur2Program;

  private static int mRadius1H,mOffsets1H,mWeights1H,mDepth1H, mColorTexture1H;

  private static int mRadius2H,mOffsets2H,mWeights2H,mDepth2H, mColorTexture2H, mDepthTexture2H;

    final InputStream blur1VertexStream   = resources.openRawResource(R.raw.blur_vertex_shader);

    final InputStream blur1FragmentStream = resources.openRawResource(R.raw.blur1_fragment_shader);

    try

      {

      mBlur1Program = new DistortedProgram(blur1VertexStream,blur1FragmentStream,

                                          Distorted.glslVersion,

                                          Distorted.glslVersion+"#define MAX_BLUR "+MAX_BLUR);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int blur1ProgramH = mBlur1Program.getProgramHandle();

    mRadius1H       = GLES30.glGetUniformLocation( blur1ProgramH, "u_Radius");

    mOffsets1H      = GLES30.glGetUniformLocation( blur1ProgramH, "u_Offsets");

    mWeights1H      = GLES30.glGetUniformLocation( blur1ProgramH, "u_Weights");

    mDepth1H        = GLES30.glGetUniformLocation( blur1ProgramH, "u_Depth");

    mColorTexture1H = GLES30.glGetUniformLocation( blur1ProgramH, "u_ColorTexture");

    final InputStream blur2VertexStream   = resources.openRawResource(R.raw.blur_vertex_shader);

    final InputStream blur2FragmentStream = resources.openRawResource(R.raw.blur2_fragment_shader);

    try

      {

      mBlur2Program = new DistortedProgram(blur2VertexStream,blur2FragmentStream,

                                          Distorted.glslVersion,

                                          Distorted.glslVersion + "#define MAX_BLUR "+MAX_BLUR);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int blur2ProgramH = mBlur2Program.getProgramHandle();

    mRadius2H       = GLES30.glGetUniformLocation( blur2ProgramH, "u_Radius");

    mOffsets2H      = GLES30.glGetUniformLocation( blur2ProgramH, "u_Offsets");

    mWeights2H      = GLES30.glGetUniformLocation( blur2ProgramH, "u_Weights");

    mDepth2H        = GLES30.glGetUniformLocation( blur2ProgramH, "u_Depth");

    mColorTexture2H = GLES30.glGetUniformLocation( blur2ProgramH, "u_ColorTexture");

    mDepthTexture2H = GLES30.glGetUniformLocation( blur2ProgramH, "u_DepthTexture");

      mBlur1Program.useProgram();

      mPostBuffer.resizeFast( (int)w, (int)h);

      mPostBuffer.setAsOutput(time);

      GLES30.glUniform1fv( mWeights1H, radius+1, weightsCache,offset);

      GLES30.glUniform1i( mRadius1H, radius);

      GLES30.glUniform1f( mDepth1H , 1.0f-surface.mNear);

      GLES30.glUniform1f( mColorTexture1H , 0 );

      for(int i=0; i<=radius; i++) mOffsets[i] = offsetsCache[offset+i]/h;

      GLES30.glUniform1fv( mOffsets1H ,radius+1, mOffsets,0);

      GLES30.glVertexAttribPointer(mBlur1Program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadPositions);

      GLES30.glVertexAttribPointer(mBlur1Program.mAttribute[1], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadTextureInv);

      mBlur2Program.useProgram();

      mMainBuffer.setAsDepth();

      GLES30.glUniform1fv( mWeights2H, radius+1, weightsCache,offset);

      GLES30.glUniform1i( mRadius2H, radius);

      GLES30.glUniform1f( mDepth2H , 1.0f-surface.mNear);

      GLES30.glUniform1f( mColorTexture2H , 0 );

      GLES30.glUniform1f( mDepthTexture2H , 1 );

      GLES30.glUniform1fv( mOffsets2H ,radius+1, mOffsets,0);

      GLES30.glVertexAttribPointer(mBlur2Program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadPositions);

      GLES30.glVertexAttribPointer(mBlur2Program.mAttribute[1], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadTextureInv);

    if( semicolon<len && semicolon-whiteSpace>=4 )   // "in a;" --> 4

      if( subline.startsWith("in "))

        for(nameBegin=subLen-1; nameBegin>1; nameBegin--)

in vec2 v_TexCoordinate;      // Interpolated texture coordinate per fragment.

out vec4 fragColor;           // The output color

  fragColor = texture(u_Texture,v_TexCoordinate);

uniform float u_Depth;    // distance from the near plane to render plane, in clip coords

in vec2 a_Position;       // Per-vertex position.

out vec2 v_TexCoordinate; //

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

// 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;

in vec2 v_TexCoordinate;

out vec4 fragColor;

uniform sampler2D u_ColorTexture;

uniform float u_Offsets[MAX_BLUR];

uniform float u_Weights[MAX_BLUR];

uniform int u_Radius;

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

void main()

  {

  vec4 pixel= texture(u_ColorTexture,v_TexCoordinate) * u_Weights[0];

  for (int i=1; i<=u_Radius; i+=1)

    {

    pixel += ( texture(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +

               texture(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];

    }

  fragColor = pixel;

  }

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

// 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;

in vec2 v_TexCoordinate;

out vec4 fragColor;

uniform sampler2D u_ColorTexture;

uniform sampler2D u_DepthTexture;

uniform float u_Offsets[MAX_BLUR];

uniform float u_Weights[MAX_BLUR];

uniform int u_Radius;

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

void main()

  {

  gl_FragDepth = 0.0;//texture(u_DepthTexture,v_TexCoordinate);

  vec4 pixel= texture(u_ColorTexture,v_TexCoordinate) * u_Weights[0];

  for (int i=1; i<=u_Radius; i+=1)

    {

    pixel += ( texture(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +

               texture(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];

    }

  fragColor = pixel;

  }

uniform float u_Depth;    // distance from the near plane to render plane, in clip coords

in vec2 a_Position;       // Per-vertex position.

in vec2 a_TexCoordinate;  // Per-vertex texture coordinate information we will pass in.

out vec2 v_TexCoordinate; //

in vec3 v_Position;                     // Interpolated position for this fragment.

in vec3 v_Normal;                       // Interpolated normal for this fragment.

in vec2 v_TexCoordinate;                // Interpolated texture coordinate per fragment.

out vec4 fragColor;                     // The output color

  vec4 pixel = texture(u_Texture,v_TexCoordinate);

  fragColor = vec4(pixel.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, pixel.a);

in vec3 a_Position;                  // Per-vertex position.

in vec3 a_Normal;                    // Per-vertex normal vector.

in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.

out vec3 v_Position;                 //

out vec3 v_Normal;                   //

out vec2 v_TexCoordinate;            //

out vec4 fragColor;

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

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