Distorted Android

  /// OIT CLEAR PROGRAM ///

  private static DistortedProgram mOITClearProgram;

  private static int mOITClearDepthH;

  private static int mOITClearTexCorrH;

  private static int mOITClearSizeH;

  /// OIT BUILD PROGRAM ///

  private static DistortedProgram mOITBuildProgram;

  private static int mOITBuildTextureH;

  private static int mOITBuildDepthTextureH;

  private static int mOITBuildDepthH;

  private static int mOITBuildTexCorrH;

  private static int mOITBuildSizeH;

  private static int mOITBuildNumRecordsH;

  /// OIT RENDER PROGRAM ///

  private static DistortedProgram mOITRenderProgram;

  private static int mOITRenderTextureH;

  private static int mOITRenderDepthTextureH;

  private static int mOITRenderDepthH;

  private static int mOITRenderTexCorrH;

  private static int mOITRenderSizeH;

      mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream,Distorted.GLSL_VERSION,Distorted.GLSL_VERSION, Distorted.GLSL);

    // OIT CLEAR PROGRAM ////////////////////////////////////

    final InputStream oitClearVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitClearFragStream = resources.openRawResource(R.raw.oit_clear_fragment_shader);

      mOITClearProgram = new DistortedProgram(oitClearVertStream,oitClearFragStream,Distorted.GLSL_VERSION,Distorted.GLSL_VERSION, Distorted.GLSL);

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT CLEAR program: "+e.getMessage());

    int oitClearProgramH   = mOITClearProgram.getProgramHandle();

    mOITClearDepthH        = GLES31.glGetUniformLocation( oitClearProgramH, "u_Depth");

    mOITClearTexCorrH      = GLES31.glGetUniformLocation( oitClearProgramH, "u_TexCorr");

    mOITClearSizeH         = GLES31.glGetUniformLocation( oitClearProgramH, "u_Size");

    // OIT BUILD PROGRAM ////////////////////////////////////

    final InputStream oitBuildVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitBuildFragStream = resources.openRawResource(R.raw.oit_build_fragment_shader);

    try

      {

      mOITBuildProgram = new DistortedProgram(oitBuildVertStream,oitBuildFragStream,Distorted.GLSL_VERSION,Distorted.GLSL_VERSION, Distorted.GLSL);

      }

    catch(Exception e)

      {

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT BUILD program: "+e.getMessage());

      throw new RuntimeException(e.getMessage());

      }

    int oitBuildProgramH   = mOITBuildProgram.getProgramHandle();

    mOITBuildTextureH      = GLES31.glGetUniformLocation( oitBuildProgramH, "u_Texture");

    mOITBuildDepthTextureH = GLES31.glGetUniformLocation( oitBuildProgramH, "u_DepthTexture");

    mOITBuildDepthH        = GLES31.glGetUniformLocation( oitBuildProgramH, "u_Depth");

    mOITBuildTexCorrH      = GLES31.glGetUniformLocation( oitBuildProgramH, "u_TexCorr");

    mOITBuildSizeH         = GLES31.glGetUniformLocation( oitBuildProgramH, "u_Size");

    mOITBuildNumRecordsH   = GLES31.glGetUniformLocation( oitBuildProgramH, "u_numRecords");

    final InputStream oitRenderVertStream = resources.openRawResource(R.raw.oit_vertex_shader);

    final InputStream oitRenderFragStream = resources.openRawResource(R.raw.oit_render_fragment_shader);

      mOITRenderProgram = new DistortedProgram(oitRenderVertStream,oitRenderFragStream,Distorted.GLSL_VERSION,Distorted.GLSL_VERSION, Distorted.GLSL);

      Log.e("EFFECTS", e.getClass().getSimpleName()+" trying to compile OIT RENDER program: "+e.getMessage());

    int oitRenderProgramH   = mOITRenderProgram.getProgramHandle();

    mOITRenderTextureH      = GLES31.glGetUniformLocation( oitRenderProgramH, "u_Texture");

    mOITRenderDepthTextureH = GLES31.glGetUniformLocation( oitRenderProgramH, "u_DepthTexture");

    mOITRenderDepthH        = GLES31.glGetUniformLocation( oitRenderProgramH, "u_Depth");

    mOITRenderTexCorrH      = GLES31.glGetUniformLocation( oitRenderProgramH, "u_TexCorr");

    mOITRenderSizeH         = GLES31.glGetUniformLocation( oitRenderProgramH, "u_Size");

                                                                GLES31.GL_MAP_WRITE_BIT|GLES31.GL_MAP_INVALIDATE_BUFFER_BIT);

// Pass1 of the OIT algorithm. Clear per-pixel head-poiners.

  static void oitClear(DistortedOutputSurface surface)

    {

    mOITClearProgram.useProgram();

    GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );

    GLES31.glUniform2f(mOITClearTexCorrH, 1.0f, 1.0f );   // corrections do not really matter here - only present because of common vertex shader.

    GLES31.glUniform1f( mOITClearDepthH , 1.0f);          // likewise depth

    GLES31.glUniform2f(mOITClearSizeH, surface.mWidth, surface.mHeight);

    GLES31.glVertexAttribPointer(mOITClearProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

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

    }

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

// Pass2 of the OIT algorithm - build per-pixel linked lists.

  static void oitBuild(DistortedOutputSurface surface, float corrW, float corrH)

    mOITBuildProgram.useProgram();

    GLES31.glUniform1i(mOITBuildTextureH, 0);

    GLES31.glUniform1i(mOITBuildDepthTextureH, 1);

    GLES31.glUniform2f(mOITBuildTexCorrH, corrW, corrH );

    GLES31.glUniform2f(mOITBuildSizeH, surface.mWidth, surface.mHeight);

    GLES31.glUniform1ui(mOITBuildNumRecordsH, (mBufferSize-surface.mWidth*surface.mHeight)/3 );  // see the fragment shader

    GLES31.glUniform1f(mOITBuildDepthH , 1.0f-surface.mNear);

    GLES31.glVertexAttribPointer(mOITBuildProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

// Pass3 of the OIT algorithm. Render all the transparent pixels from the per-pixel linked lists.

  static void oitRender(DistortedOutputSurface surface, float corrW, float corrH)

    mOITRenderProgram.useProgram();

    GLES31.glUniform1i(mOITRenderTextureH, 0);

    GLES31.glUniform1i(mOITRenderDepthTextureH, 1);

    GLES31.glUniform2f(mOITRenderTexCorrH, corrW, corrH );

    GLES31.glUniform2f(mOITRenderSizeH, surface.mWidth, surface.mHeight);

    GLES31.glUniform1f( mOITRenderDepthH , 1.0f-surface.mNear);

    GLES31.glVertexAttribPointer(mOITRenderProgram.mAttribute[0], 2, GLES31.GL_FLOAT, false, 0, mQuadPositions);

  private static DistortedOutputSurface   mBufferOIT;

  private static void createPostprocessingBuffers(int width, int height, float near)

    for (int j=0; j<EffectQuality.LENGTH; j++)

      mBuffer[j] = new DistortedFramebuffer(2, BOTH_DEPTH_STENCIL, TYPE_SYST, (int) (width * mipmap), (int) (height * mipmap));

      mBuffer[j].mNear = near;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )

      mBuffer[j].glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

    GLES31.glColorMask(true, true, true, true);

    GLES31.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

    for (int j=0; j<EffectQuality.LENGTH; j++)

      GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT | GLES31.GL_DEPTH_BUFFER_BIT | GLES31.GL_STENCIL_BUFFER_BIT);

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

  private static void initializeOIT(DistortedOutputSurface surface)

    {

    if( mBufferOIT==null )

      {

      mBufferOIT = new DistortedFramebuffer(1, BOTH_DEPTH_STENCIL, TYPE_SYST, surface.mWidth, surface.mHeight);

      mBufferOIT.mMipmap = 1.0f;

      mBufferOIT.mNear = surface.mNear;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )

      mBufferOIT.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

      DistortedObject.toDo(); // create the FBOs immediately. This is safe as we must be holding the OpenGL context now.

      mBufferOIT.setAsOutput();

      GLES31.glFramebufferTexture2D(GLES31.GL_FRAMEBUFFER, GLES31.GL_COLOR_ATTACHMENT0, GLES31.GL_TEXTURE_2D, mBufferOIT.mColorH[0], 0);

      GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT | GLES31.GL_DEPTH_BUFFER_BIT | GLES31.GL_STENCIL_BUFFER_BIT);

      }

    if( mBufferOIT.mWidth != surface.mWidth || mBufferOIT.mHeight != surface.mHeight )

      {

      mBufferOIT.mWidth  = (int)(surface.mWidth *mBufferOIT.mMipmap);

      mBufferOIT.mHeight = (int)(surface.mHeight*mBufferOIT.mMipmap);

      mBufferOIT.mNear   = surface.mNear;  // Near plane is independent of the mipmap level

      //android.util.Log.e("surface", "viewport "+i+" to ("+from.mWidth+"x"+from.mHeight+")");

      mBufferOIT.createProjection();

      int maxw = mBufferOIT.mWidth  > mBufferOIT.mRealWidth  ? mBufferOIT.mWidth  : mBufferOIT.mRealWidth;

      int maxh = mBufferOIT.mHeight > mBufferOIT.mRealHeight ? mBufferOIT.mHeight : mBufferOIT.mRealHeight;

      if (maxw > mBufferOIT.mRealWidth || maxh > mBufferOIT.mRealHeight)

        {

        mBufferOIT.mRealWidth = maxw;

        mBufferOIT.mRealHeight = maxh;

        mBufferOIT.recreate();

        mBufferOIT.create();

        }

      }

    if( mBufferOIT.mNear != surface.mNear || mBufferOIT.mFOV != surface.mFOV )

      {

      mBufferOIT.mNear = surface.mNear;

      mBufferOIT.mFOV  = surface.mFOV;

      mBufferOIT.createProjection();

      }

    GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);

    DistortedRenderState.colorDepthStencilOn();

    GLES31.glClearColor(surface.mClearR, surface.mClearG, surface.mClearB, surface.mClearA);

    GLES31.glClearDepthf(surface.mClearDepth);

    GLES31.glClearStencil(surface.mClearStencil);

    GLES31.glClear(surface.mClear);

    DistortedRenderState.colorDepthStencilRestore();

    DistortedEffects.zeroOutAtomic();

    DistortedEffects.oitClear(surface);

    GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT|GLES31.GL_ATOMIC_COUNTER_BARRIER_BIT);

    }

    mBufferOIT = null;

  private static void clonePostprocessingViewport(DistortedOutputSurface from)

    if( mBuffer[0].mWidth != from.mWidth || mBuffer[0].mHeight != from.mHeight )

  private int oitBuild(long currTime, DistortedOutputSurface buffer)

    //GLES31.glDisable(GLES31.GL_STENCIL_TEST);

    //GLES31.glStencilMask(0x00);

    DistortedRenderState.colorDepthStencilOn();

    DistortedRenderState.enableDepthTest();

    DistortedEffects.oitBuild(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );

    DistortedRenderState.colorDepthStencilRestore();

    DistortedRenderState.restoreDepthTest();

  private int oitRender(long currTime, DistortedOutputSurface buffer)

    GLES31.glActiveTexture(GLES31.GL_TEXTURE0);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mColorH[0]);

    DistortedEffects.oitRender(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );

// to a whole buffer (lastQueue.postprocess) and merge it (this.oitBuild).

    long lastBucket=0, currBucket=0;

    initializeOIT(this);

      if( currBucket==0 )

        {

        GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);

        numRenders += child1.draw(time, mBufferOIT);

        //setAsOutput(time);

        //numRenders += child1.draw(time,this);

        }

        if( mBuffer[0]==null ) createPostprocessingBuffers(mWidth,mHeight,mNear);

            clonePostprocessingViewport(this);

            numRenders += mBufferOIT.oitBuild(time, mBuffer[quality]);

        mBuffer[quality].setAsOutput(time);

          numRenders += mBufferOIT.oitBuild(time, mBuffer[quality]);

          GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT);

          numRenders += oitRender(time,mBufferOIT);  // merge the OIT linked list

        } // end else (postprocessed child)

      } // end main for loop

    if( currBucket==0 ) // there was no postprocessing - we need to merge the main buffer

      {

      numRenders += oitRender(time,mBufferOIT);

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

  static void enableDepthTest()

    {

    sState.depthTest = cState.depthTest;

    if (cState.depthTest != 1)

      {

      cState.depthTest = 1;

      GLES31.glEnable(GLES31.GL_DEPTH_TEST);

      }

    }

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

  static void restoreDepthTest()

    {

    if (sState.depthTest != cState.depthTest)

      {

      cState.depthTest = sState.depthTest;

      if (cState.depthTest == 0)

        {

        GLES31.glDisable(GLES31.GL_DEPTH_TEST);

        }

      else

        {

        GLES31.glEnable(GLES31.GL_DEPTH_TEST);

        }

      }

    }

  fragColor = texture(u_Texture,v_TexCoordinate);

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

// Copyright 2018 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 highp float;

precision highp int;

out vec4 fragColor;

in vec2 v_TexCoordinate;

in vec2 v_Pixel;              // location of the current fragment, in pixels

uniform sampler2D u_Texture;

uniform sampler2D u_DepthTexture;

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

// per-pixel linked list. Order Independent Transparency.

uniform vec2 u_Size;

uniform uint u_numRecords;

layout (binding=0, offset=0) uniform atomic_uint u_Counter;

layout (std430,binding=1) buffer linkedlist  // first (u_Size.x*u_Size.y) uints - head pointers,

  {                                          // one for each pixel in the Output rectangle.

  uint u_Records[];                          //

  };                                         // Next 3*u_numRecords uints - actual linked list, i.e.

                                             // triplets of (pointer,depth,rgba).

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

// Concurrent insert to a linked list. Tim Harris, 'pragmatic implementation of non-blocking

// linked-lists', 2001.

// This arranges fragments by decreasing 'depth', so one would think - from back to front, but

// in main() below the depth is mapped with S*(1-depth)/2, so it is really front to back.

void insert( vec2 ij, uint depth, uint rgba )

  {

  uint ptr = atomicCounterIncrement(u_Counter);

  if( ptr<u_numRecords )

    {

    ptr = 3u*ptr + uint(u_Size.x*u_Size.y);

    u_Records[ptr+1u] = depth;

    u_Records[ptr+2u] = rgba;

    memoryBarrier();

    uint prev = uint(ij.x + ij.y * u_Size.x);

    uint curr = u_Records[prev];

    while (true)

      {

      if ( curr==0u || depth > u_Records[curr+1u] )  // need to insert here

        {

        u_Records[ptr] = curr;     // next of new record is curr

        memoryBarrier();

        uint res = atomicCompSwap( u_Records[prev], curr, ptr );

        if (res==curr) break;      // done!

        else           curr = res; // could not insert! retry from same place in list

        }

      else                         // advance in list

        {

        prev = curr;

        curr = u_Records[prev];

        }

      }

    discard;

    }

  }

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

uint convert(vec4 c)

  {

  return ((uint(255.0*c.r))<<24u) + ((uint(255.0*c.g))<<16u) + ((uint(255.0*c.b))<<8u) + uint(255.0*c.a);

  }

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

// Pass2 of the OIT algorithm - build the LinkedList phase.

void main()                    		

  {

  vec4 frag  = texture(u_Texture     , v_TexCoordinate);

  float depth= texture(u_DepthTexture, v_TexCoordinate).r;

  if( frag.a > 0.95 )

    {

    gl_FragDepth = depth;

    fragColor    = frag;

    }

  else

    {

    if( frag.a > 0.0 )

      {

      const float S= 2147483647.0; // max signed int. Could probably be max unsigned int but this is enough.

      insert(v_Pixel, uint(S*(1.0-depth)/2.0), convert(frag) );

      }

    discard;

    }

  }

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

// Copyright 2018 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 highp float;

precision highp int;

in vec2 v_TexCoordinate;

in vec2 v_Pixel;              // location of the current fragment, in pixels

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

// per-pixel linked list. Order Independent Transparency.

uniform vec2 u_Size;

layout (std430,binding=1) buffer linkedlist  // first (u_Size.x*u_Size.y) uints - head pointers,

  {                                          // one for each pixel in the Output rectangle.

  uint u_Records[];                          //

  };                                         // Next 3*u_numRecords uints - actual linked list, i.e.

                                             // triplets of (pointer,depth,rgba).

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

// Pass1 of the OIT algorithm - 'clear the head pointers' phase.

// No we cannot optimize this out by moving the 'u_Records[index]=0u' to the end of the Pass3,

// because between passes the size of the surface we render to might change.

void main()                    		

  {

  uint index= uint(v_Pixel.x + v_Pixel.y * u_Size.x);

  u_Records[index] = 0u;

  discard;

  }

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

// Copyright 2018 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 highp float;

precision highp int;

out vec4 fragColor;           // The output color

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

in vec2 v_Pixel;              // location of the current fragment, in pixels

uniform sampler2D u_Texture;

uniform sampler2D u_DepthTexture;

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

// per-pixel linked list. Order Independent Transparency.

uniform vec2 u_Size;

layout (std430,binding=1) buffer linkedlist  // first (u_Size.x*u_Size.y) uints - head pointers,

  {                                          // one for each pixel in the Output rectangle.

  uint u_Records[];                          //

  };                                         // Next 3*u_numRecords uints - actual linked list, i.e.

                                             // triplets of (pointer,depth,rgba).

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

vec4 convert(uint rgba)

  {

  return vec4( float((rgba>>24u)&255u),float((rgba>>16u)&255u),float((rgba>>8u)&255u),float(rgba&255u) ) / 255.0;

  }

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

// https://en.wikipedia.org/wiki/Alpha_compositing (premultiplied)

vec4 blend(vec4 clr,vec4 srf)

  {

  return clr + (1.0 - clr.a) * vec4(srf.rgb * srf.a , srf.a);

  }

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

// Pass3 of the OIT algorithm - traverse the per-pixel LinkedList and build the final color.

void main()                    		

  {

  float texdepth = texture(u_DepthTexture, v_TexCoordinate).r;

  vec4  color    = texture(u_Texture     , v_TexCoordinate);

  uint  index    = uint(v_Pixel.x + v_Pixel.y * u_Size.x);

  uint  curr     = u_Records[index];

  if (curr != 0u)

    {

    const float S= 2147483647.0;

    uint depth = u_Records[curr+1u];

    uint texdepthuint = uint(S*(1.0-texdepth)/2.0);

    if( depth >= texdepthuint )

      {

      vec4 clr= convert(u_Records[curr+2u]);

      curr = u_Records[curr];

      while (curr > 0u)

        {

        depth= u_Records[curr+1u];                       // keep walking the linked list

        if( depth < texdepthuint ) break;                // until we reach scene depth

        clr= blend( clr, convert(u_Records[curr+2u]) );  // and blending the colors in

        curr = u_Records[curr];

        }

      color = blend( clr, color);

      }

    }

  gl_FragDepth = texdepth;

  fragColor    = color;

  }

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

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

precision highp int;

in vec2 a_Position;           // Per-vertex position.

out vec2 v_TexCoordinate;     //

out vec2 v_Pixel;             // 2D pixel coords in window space

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

uniform vec2  u_TexCorr;      // when we blit from postprocessing buffers, the buffers can be

                              // larger than necessary (there is just one static set being

                              // reused!) so we need to compensate here by adjusting the texture

                              // coords.

uniform vec2 u_Size;          // size of the output surface, in pixels.

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

void main()

  {

  v_TexCoordinate = (a_Position + 0.5) * u_TexCorr;

  v_Pixel         = (a_Position + 0.5) * u_Size;

  gl_Position     = vec4(2.0*a_Position,u_Depth,1.0);

  }