Distorted Android

import java.nio.IntBuffer;

  private static int mBlitDepthSizeH;

  private static int mBlitDepthNumRecordsH;

  private static int[] mLinkedListSSBO = new int[1];

  private static int[] mAtomicCounter = new int[1];

  static

    {

    mLinkedListSSBO[0]= -1;

    mAtomicCounter[0] = -1;

    }

  private static int mBufferSize=(0x1<<23);  // 8 million entries

  private static IntBuffer mIntBuffer;

  /// BLIT DEPTH RENDER PROGRAM ///

  private static DistortedProgram mBlitDepthRenderProgram;

  private static int mBlitDepthRenderDepthTextureH;

  private static int mBlitDepthRenderDepthH;

  private static int mBlitDepthRenderTexCorrH;

  private static int mBlitDepthRenderSizeH;

    mBlitDepthSizeH         = GLES31.glGetUniformLocation( blitDepthProgramH, "u_Size");

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

    mIntBuffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();

    mIntBuffer.put(0,0);

    if( mLinkedListSSBO[0]<0 )

      {

      GLES31.glGenBuffers(1,mLinkedListSSBO,0);

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mLinkedListSSBO[0]);

      GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);

      GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 1, mLinkedListSSBO[0]);

      }

    if( mAtomicCounter[0]<0 )

      {

      GLES31.glGenBuffers(1,mAtomicCounter,0);

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

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

      GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0);

      }

    // BLIT DEPTH RENDER PROGRAM ///////////////////////////

    final InputStream blitDepthRenderVertStream = resources.openRawResource(R.raw.blit_depth_vertex_shader);

    final InputStream blitDepthRenderFragStream = resources.openRawResource(R.raw.blit_depth_render_fragment_shader);

    try

      {

      mBlitDepthRenderProgram = new DistortedProgram(blitDepthRenderVertStream,blitDepthRenderFragStream,blitVertHeader,blitFragHeader, Distorted.GLSL);

      }

    catch(Exception e)

      {

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

      throw new RuntimeException(e.getMessage());

      }

    int blitDepthRenderProgramH   = mBlitDepthRenderProgram.getProgramHandle();

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

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

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

    mBlitDepthRenderSizeH         = GLES31.glGetUniformLocation( blitDepthRenderProgramH, "u_Size");

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mesh.mAttVBO[0]);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[0], MeshObject.POS_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET0);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[1], MeshObject.NOR_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET1);

    GLES31.glVertexAttribPointer(mMainProgram.mAttribute[2], MeshObject.TEX_DATA_SIZE, GLES31.GL_FLOAT, false, MeshObject.VERTSIZE, MeshObject.OFFSET2);

    GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, 0);

    GLES31.glUniform2i(mBlitDepthSizeH, surface.mWidth, surface.mHeight);

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

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

    //android.util.Log.e("effects", "bufferSize: "+mBufferSize+" numRecords: "+((mBufferSize-surface.mWidth*surface.mHeight)/3) );

    }

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

// render all the transparent pixels from the per-pixel linked lists. This is in the 'merge

// postprocessing buckets' stage.

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

    {

    mBlitDepthRenderProgram.useProgram();

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

    GLES31.glUniform1i(mBlitDepthRenderDepthTextureH, 1);

    GLES31.glUniform2f(mBlitDepthRenderTexCorrH, corrW, corrH );

    GLES31.glUniform2i(mBlitDepthRenderSizeH, surface.mWidth, surface.mHeight);

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

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

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

    // reset atomic counter to 0

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

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

    GLES31.glBindBuffer(GLES31.GL_ATOMIC_COUNTER_BUFFER, 0);

    mNextID           =  0;

    mLinkedListSSBO[0]= -1;

    mAtomicCounter[0] = -1;

    return 1;

    }

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

  private int blitWithDepthRender(long currTime, DistortedOutputSurface buffer)

    {

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

    setAsOutput(currTime);

    GLES31.glActiveTexture(GLES31.GL_TEXTURE1);

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

    DistortedRenderState.enableStencil();

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

    GLES31.glActiveTexture(GLES31.GL_TEXTURE1);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);

    DistortedRenderState.restoreStencil();

    return 1;

    }

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

  private void clearBuffer(DistortedOutputSurface buffer)

    {

            clearBuffer(mBuffer[quality]);

          numRenders += blitWithDepthRender(time,mBuffer[quality]);  // merge the OIT linked list

          clearBuffer(mBuffer[quality]);

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

  static void enableStencil()

    {

    sState.stencilTest = cState.stencilTest;

    if (cState.stencilTest != 1)

      {

      cState.stencilTest = 1;

      GLES31.glEnable(GLES31.GL_STENCIL_TEST);

      }

    sState.stencilFuncFunc = cState.stencilFuncFunc;

    sState.stencilFuncRef  = cState.stencilFuncRef;

    sState.stencilFuncMask = cState.stencilFuncMask;

    if( cState.stencilFuncFunc!=GLES31.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK )

      {

      cState.stencilFuncFunc = GLES31.GL_EQUAL;

      cState.stencilFuncRef  = 1;

      cState.stencilFuncMask = STENCIL_MASK;

      GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);

      }

    sState.stencilMask = cState.stencilMask;

    if( cState.stencilMask!= 0x00 )

      {

      cState.stencilMask = 0x00;

      GLES31.glStencilMask(cState.stencilMask);

      }

    }

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

  static void restoreStencil()

    {

    if (sState.stencilTest != cState.stencilTest)

      {

      cState.stencilTest = sState.stencilTest;

      if (cState.stencilTest == 0)

        {

        GLES31.glDisable(GLES31.GL_STENCIL_TEST);

        }

      else

        {

        GLES31.glEnable(GLES31.GL_STENCIL_TEST);

        }

      }

    if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask )

      {

      cState.stencilFuncFunc = sState.stencilFuncFunc;

      cState.stencilFuncRef  = sState.stencilFuncRef ;

      cState.stencilFuncMask = sState.stencilFuncMask;

      GLES31.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);

      }

    if( sState.stencilMask!=cState.stencilMask )

      {

      cState.stencilMask = sState.stencilMask;

      GLES31.glStencilMask(cState.stencilMask);

      }

    }

// Copyright 2018 Leszek Koltunski                                                          //

precision highp uint;

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

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

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

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

  {

  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.

    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 lowp float;

precision highp uint;

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

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

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

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

  }

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

void main()                    		

  {

  uint index = uint(v_Pixel.x + v_Pixel.y * float(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)                                      // keep walking the linked list

    {                                                    // and blending the colors in

    curr = u_Records[curr];                              //

    //color= blend( color, convert(u_Records[curr+2u]) );  //

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

    if( color.a == 0.0 ) color = vec4(0.0,1.0,0.0,1.0);

    }

  gl_FragDepth = TEXTURE(u_DepthTexture, v_TexCoordinate).r;

  FRAG_COLOR = color;

//else

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

  }

precision highp uint;

out vec2 v_Pixel;             //

varying vec2 v_Pixel;         //

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

  v_Pixel         = v_TexCoordinate * vec2(u_Size);