Distorted Android

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

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

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

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

uniform uvec2 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;

  }

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

// A over B (https://en.wikipedia.org/wiki/Alpha_compositing)

vec4 blend(vec4 A,vec4 B)

  {

  float b = B.a * (1.0-A.a);

  float a = A.a + b;

  return vec4( (A.rgb*A.a + B.rgb*b)/a , a );

  }

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

// Pass4 of the OIT algorithm - keep traversing the linked list, build the final color and blend it.

void main()                    		

  {

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

  uint curr = u_Records[prev];

  if (curr != 0u)

    {

    const float S= 2147483647.0;

    gl_FragDepth = 1.0 - 2.0*float(u_Records[curr+1u])/S;

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

    curr = u_Records[curr];

    while (curr != 0u)

      {

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

      curr = u_Records[curr];

      }

    fragColor = color;

    }

  else discard;

  }