Distorted Android

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

// Copyright 2016 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;

uniform sampler2D u_Texture;            // The input texture.

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

varying vec4 v_Color;                   // This is the color from the vertex shader interpolated across the triangle per fragment.

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

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

uniform int fNumEffects;                // total number of fragment effects

#if NUM_FRAGMENT>0

uniform int fType[NUM_FRAGMENT];        // their types.

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

                                        // next describes the Region, i.e. area over which the effect is active.

const vec3 LUMI3= vec3( 0.2125, 0.7154, 0.0721 );

const vec3 ZERO3= vec3(0.0,0.0,0.0);

const vec3 HALF3= vec3(0.5,0.5,0.5);

const vec2 ONE2 = vec2(1.0,1.0);

const vec2 HALF2= vec2(0.5,0.5);

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

// MACROBLOCK EFFECT

void macroblock(float degree, int effect, inout vec4 pixel)

  {

  vec2 a = degree*(fUniforms[effect].yz-ONE2)+ONE2;

  vec2 tex = ( max((1.0-degree)*v_TexCoordinate,floor(v_TexCoordinate*a)) + degree*HALF2 ) / a;

  pixel = texture2D(u_Texture, tex);

  }

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

// CHROMA EFFECT

void chroma(float degree, int effect, inout vec4 pixel)

  {

  pixel = vec4( mix( pixel.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x), pixel.a);

  }

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

// ALPHA EFFECT (change transparency level)

void alpha(float degree, int effect, inout vec4 pixel)

  {

  pixel.a *= (degree*(fUniforms[effect].x-1.0)+1.0);

  }

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

// BRIGHTNESS EFFECT

void brightness(float degree, int effect, inout vec4 pixel)

  {

  pixel.rgb = mix(ZERO3, pixel.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );

  }

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

// CONTRAST EFFECT

void contrast(float degree, int effect, inout vec4 pixel)

  {

  pixel.rgb = mix(HALF3, pixel.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );

  }

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

// SATURATION EFFECT

void saturation(float degree, int effect, inout vec4 pixel)

  {

  float luminance = dot(LUMI3,pixel.rgb);

  pixel.rgb = mix(vec3(luminance,luminance,luminance), pixel.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );

  }

#endif

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

void main()                    		

  {  

  vec4 pixel = texture2D(u_Texture, v_TexCoordinate);

#if NUM_FRAGMENT>0

  vec2 diff;

  float pointDegree;

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

    {

    diff = (v_Position.xy - fUniforms[2*i+1].xy)/fUniforms[2*i+1].zw;

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

         if( fType[i]==MACROBLOCK        ) macroblock(sign(pointDegree),2*i, pixel);

    else if( fType[i]==CHROMA            ) chroma    (sign(pointDegree),2*i, pixel);

    else if( fType[i]==SMOOTH_CHROMA     ) chroma    (     pointDegree ,2*i, pixel);

    else if( fType[i]==ALPHA             ) alpha     (sign(pointDegree),2*i, pixel);

    else if( fType[i]==SMOOTH_ALPHA      ) alpha     (     pointDegree ,2*i, pixel);

    else if( fType[i]==BRIGHTNESS        ) brightness(sign(pointDegree),2*i, pixel);

    else if( fType[i]==SMOOTH_BRIGHTNESS ) brightness(     pointDegree ,2*i, pixel);

    else if( fType[i]==CONTRAST          ) contrast  (sign(pointDegree),2*i, pixel);

    else if( fType[i]==SMOOTH_CONTRAST   ) contrast  (     pointDegree ,2*i, pixel);

    else if( fType[i]==SATURATION        ) saturation(sign(pointDegree),2*i, pixel);

    else if( fType[i]==SMOOTH_SATURATION ) saturation(     pointDegree ,2*i, pixel);

    }

#endif

  gl_FragColor = pixel*0.5*(v_Normal.z+1.0);

  }