Distorted Android

#if __VERSION__ != 100

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

#define TEXTURE texture

#define FRAG_COLOR fragColor

#else

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

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

#define TEXTURE texture2D

#define FRAG_COLOR gl_FragColor

#endif

uniform sampler2D u_Texture;

uniform sampler2D u_DepthTexture;

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

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

uniform ivec2 u_Size;

uniform uint u_numRecords;

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

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 insert2( vec2 ij, uint depth, uint rgba )

  {

/*

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

  u_Records[index] = (255u<<24u)+ uint( (int(255*int(ij.y)/u_Size.y))<<16u ) + (255u);

  discard;

*/

  uint ptr = atomicCounterIncrement(u_Counter);

  if( ptr<u_numRecords )

    {

    ptr = ptr /*uint(ij.x + ij.y * float(u_Size.x))*/ + uint(u_Size.x*u_Size.y);

    u_Records[ptr   ] = (255u<<( (2*int(ij.x) > u_Size.x) ? 24u:16u)) + (255u);

    //u_Records[ptr+1u] = depth;

    //u_Records[ptr+2u] = rgba;

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

    u_Records[index] = ptr;

    discard;

    }

  }

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;

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

    u_Records[index] = ptr;

    }

/*

  uint ptr = atomicCounterIncrement(u_Counter)-1u;

  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 * float(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];

        }

      }

*/

//    }

  }

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

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;

    FRAG_COLOR   = 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.

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

    //}