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;

#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 ptr = u_Records[index];

  if( ptr == 0u ) discard;

  else

    {

    u_Records[index] = 0u;

    vec4 color = convert(u_Records[ptr]);

         if( (4*int(v_Pixel.x) > u_Size.x) && color.r==1.0 ) FRAG_COLOR = color;

    else if( (4*int(v_Pixel.x) <=u_Size.x) && color.g==1.0 ) FRAG_COLOR = color;

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

    //FRAG_COLOR = convert(u_Records[index]);

    //u_Records[index] = 0u;

    }

  /*

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

    }

  if( curr>0u )

    {

    curr = u_Records[curr];

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

    }

  gl_FragDepth = TEXTURE(u_DepthTexture, v_TexCoordinate).r;

  FRAG_COLOR = color;

//else

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

*/

  }