Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                          //

//                                                                                          //

// This file is part of DistortedLibrary.                                                          //

//                                                                                          //

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

//                                                                                          //

// DistortedLibrary 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 DistortedLibrary.  If not, see <http://www.gnu.org/licenses/>.                       //

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

precision highp float;

precision highp int;

in vec3 v_Position;                     // Interpolated position for this fragment.

in vec3 v_Normal;                       // Interpolated normal for this fragment.

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

out vec4 fragColor;                     // The output color

uniform sampler2D u_Texture;            // The input texture.

#ifdef OIT

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

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

uniform uvec2 u_Size;

uniform uint u_numRecords;

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

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

#endif

#if NUM_FRAGMENT>0

uniform int fNumEffects;                // total number of fragment effects

uniform int fName[NUM_FRAGMENT];        // their namess.

uniform vec4 fUniforms[3*NUM_FRAGMENT]; // i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].

                                        // The first vec4 is the Interpolated values,

                                        // second vec4: first float - cache, next 3: Center, the third - the Region.

#endif    // NUM_FRAGMENT>0

#ifdef OIT

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

// 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 + u_Size.x*u_Size.y;

    u_Records[ptr+1u] = depth;

    u_Records[ptr+2u] = rgba;

    memoryBarrier();

    uint prev = uint(ij.x) + uint(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];

        }

      }

    }

  }

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

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

  }

#endif   // OIT

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

void main()                    		

  {  

  vec4 color = texture(u_Texture,v_TexCoordinate);

#if NUM_FRAGMENT>0

  vec3 diff;

  float degree;

  int effect=0;

  for(int i=0; i<fNumEffects; i++)

    {

    diff   = (v_Position - fUniforms[effect+1].yzw)/fUniforms[effect+2].xyz;

    degree = max(0.0,1.0-dot(diff,diff));

    // ENABLED EFFECTS WILL BE INSERTED HERE

    effect+=3;

    }

#endif

  float z = v_Normal.z;

  if( z<0.0 ) z = -z;

  vec4 converted = vec4(color.rgb * (1.0 + 7.0*z) * 0.125, color.a);

#ifdef OIT

  if( converted.a > 0.97 )

    {

    fragColor= converted;

    }

  else

    {

    if( converted.a > 0.0 )

      {

      const float S= 2147483647.0; // max signed int. Could probably be max unsigned int but this is enough.

      vec2 pixel = vec2(gl_FragCoord.xy);

      insert(pixel, uint(S*(1.0-gl_FragCoord.z)/2.0), convert(converted) );

      }

    discard;

    }

#else

  fragColor = converted;

#endif

  }