Distorted Android

  private static int mBlitDepthTextureH;

  private static int mBlitDepthDepthTextureH;

  private static int mBlitDepthDepthH;

  private static int mBlitDepthTexCorrH;

  private static int mBlitDepthNumRecordsH;

  private static int mBlitDepthRenderDepthTextureH;

  private static int mBlitDepthRenderDepthH;

  private static int mBlitDepthRenderTexCorrH;

    mBlitDepthTextureH      = GLES31.glGetUniformLocation( blitDepthProgramH, "u_Texture");

    mBlitDepthDepthTextureH = GLES31.glGetUniformLocation( blitDepthProgramH, "u_DepthTexture");

    mBlitDepthDepthH        = GLES31.glGetUniformLocation( blitDepthProgramH, "u_Depth");

    mBlitDepthTexCorrH      = GLES31.glGetUniformLocation( blitDepthProgramH, "u_TexCorr");

    mBlitDepthNumRecordsH   = GLES31.glGetUniformLocation( blitDepthProgramH, "u_numRecords");

      GLES31.glBufferData(GLES31.GL_ATOMIC_COUNTER_BUFFER, 4, null, GLES31.GL_DYNAMIC_DRAW);

    mBlitDepthRenderDepthTextureH = GLES31.glGetUniformLocation( blitDepthRenderProgramH, "u_DepthTexture");

    mBlitDepthRenderDepthH        = GLES31.glGetUniformLocation( blitDepthRenderProgramH, "u_Depth");

    mBlitDepthRenderTexCorrH      = GLES31.glGetUniformLocation( blitDepthRenderProgramH, "u_TexCorr");

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

// reset atomic counter to 0

  static void zeroOutAtomic()

    {

    GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, mAtomicCounter[0] );

    ByteBuffer atomicBuf = (ByteBuffer)GLES31.glMapBufferRange( GLES31.GL_ATOMIC_COUNTER_BUFFER, 0, 4,

                                                                GLES31.GL_MAP_READ_BIT|GLES31.GL_MAP_WRITE_BIT);

    if( atomicBuf!=null )

      {

      IntBuffer atomicIntBuf = atomicBuf.order(ByteOrder.nativeOrder()).asIntBuffer();

      int counter = atomicIntBuf.get(0);

      atomicIntBuf.put(0, 0);

      //android.util.Log.e("counter", "now = "+counter+" w="+surface.mWidth+" h="+surface.mHeight

      //                             +" diff="+(counter-surface.mWidth*surface.mHeight));

      }

    else

      {

      android.util.Log.e("counter", "failed to map buffer");

      }

    GLES31.glUnmapBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER);

    GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0);

    }

    GLES31.glUniform1i(mBlitDepthTextureH, 0);

    GLES31.glUniform1i(mBlitDepthDepthTextureH, 1);

    GLES31.glUniform2f(mBlitDepthTexCorrH, corrW, corrH );

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

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

    GLES31.glUniform1i(mBlitDepthRenderDepthTextureH, 1);

    GLES31.glUniform2f(mBlitDepthRenderTexCorrH, corrW, corrH );

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

    ByteBuffer buf = (ByteBuffer)GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, mBufferSize*4, GLES31.GL_MAP_READ_BIT);

    IntBuffer intBuf = buf.order(ByteOrder.nativeOrder()).asIntBuffer();

        ptr = intBuf.get(index);

            ptr = intBuf.get(ptr);

          if( lastBucket==0 )

            {

            DistortedEffects.zeroOutAtomic();

            }

          else

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 uint u_numRecords;

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   ] = 0u;

    u_Records[ptr+1u] = depth;

    u_Records[ptr+2u] = rgba;//(255u<<16u) + (255u);//rgba;

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

    u_Records[index] = ptr;

    discard;

    }

*/

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

  }

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

    }

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

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

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

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

  }

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

  uint curr = u_Records[index];

  if (curr == 0u) discard;

  vec4 color= vec4(0.0,0.0,0.0,0.0);

  u_Records[index] = 0u;

  while (curr > 0u)

    {

    color= blend( color, convert(u_Records[curr+2u]) );  // keep walking the linked list

    curr = u_Records[curr];                              // and blending the colors in

    }

  gl_FragDepth = texture(u_DepthTexture, v_TexCoordinate).r;

  fragColor    = color;

in vec2 a_Position;           // Per-vertex position.

out vec2 v_TexCoordinate;     //

out vec2 v_Pixel;             //

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.

  v_TexCoordinate = (a_Position + 0.5) * u_TexCorr;

  v_Pixel         = v_TexCoordinate * u_Size;

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