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

#if __VERSION__ != 100

in vec3 a_Position;                  // Per-vertex position.

in vec3 a_Normal;                    // Per-vertex normal vector.

in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.

out vec3 v_Position;                 //

out vec3 v_endPosition;              // for Transform Feedback only

out vec3 v_Normal;                   //

out vec2 v_TexCoordinate;            //

#else

attribute vec3 a_Position;           // Per-vertex position.

attribute vec3 a_Normal;             // Per-vertex normal vector.

attribute vec2 a_TexCoordinate;      // Per-vertex texture coordinate.

varying vec3 v_Position;             //

varying vec3 v_endPosition;          // for Transform Feedback only

varying vec3 v_Normal;               //

varying vec2 v_TexCoordinate;        //

#endif

uniform vec3 u_objD;                 // half of object width x half of object height X half the depth;

                                     // point (0,0,0) is the center of the object

uniform mat4 u_MVPMatrix;            // the combined model/view/projection matrix.

uniform mat4 u_MVMatrix;             // the combined model/view matrix.

#if NUM_VERTEX>0

uniform int vNumEffects;             // total number of vertex effects

uniform int vName[NUM_VERTEX];       // their names.

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

                                     // The first vec4 is the Interpolated values,

                                     // next is half cache half Center, the third -  the Region.

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

// HELPER FUNCTIONS

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

// The trick below is the if-less version of the

//

// t = dx<0.0 ? (u_objD.x-v.x) / (u_objD.x-ux) : (u_objD.x+v.x) / (u_objD.x+ux);

// h = dy<0.0 ? (u_objD.y-v.y) / (u_objD.y-uy) : (u_objD.y+v.y) / (u_objD.y+uy);

// d = min(t,h);

//

// float d = min(-ps.x/(sign(ps.x)*u_objD.x+p.x),-ps.y/(sign(ps.y)*u_objD.y+p.y))+1.0;

//

// We still have to avoid division by 0 when p.x = +- u_objD.x or p.y = +- u_objD.y (i.e on the edge of the Object)

// We do that by first multiplying the above 'float d' with sign(denominator1*denominator2)^2.

//

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

// return degree of the point as defined by the bitmap rectangle

float degree_bitmap(in vec2 S, in vec2 PS)

  {

  vec2 A = sign(PS)*u_objD.xy + S;

  vec2 signA = sign(A);                           //

  vec2 signA_SQ = signA*signA;                    // div = PS/A if A!=0, 0 otherwise.

  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));//

  return 1.0-max(div.x,div.y);

  }

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

// Return degree of the point as defined by the Region. Currently only supports circular regions.

//

// Let us first introduce some notation.

// Let 'PS' be the vector from point P (the current vertex) to point S (the center of the effect).

// Let region.xy be the vector from point S to point O (the center point of the region circle)

// Let region.z be the radius of the region circle.

// (This all should work regardless if S is inside or outside of the circle).

//

// Then, the degree of a point with respect to a given (circular!) Region is defined by:

//

// If P is outside the circle, return 0.

// Otherwise, let X be the point where the halfline SP meets the region circle - then return |PX|/||SX|,

// aka the 'degree' of point P.

//

// We solve the triangle OPX.

// We know the lengths |PO|, |OX| and the angle OPX, because cos(OPX) = cos(180-OPS) = -cos(OPS) = -PS*PO/(|PS|*|PO|)

// then from the law of cosines PX^2 + PO^2 - 2*PX*PO*cos(OPX) = OX^2 so PX = -a + sqrt(a^2 + OX^2 - PO^2)

// where a = PS*PO/|PS| but we are really looking for d = |PX|/(|PX|+|PS|) = 1/(1+ (|PS|/|PX|) ) and

// |PX|/|PS| = -b + sqrt(b^2 + (OX^2-PO^2)/PS^2) where b=PS*PO/|PS|^2 which can be computed with only one sqrt.

float degree_region(in vec4 region, in vec2 PS)

  {

  vec2 PO  = PS + region.xy;

  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2

  if( D<=0.0 ) return 0.0;

  float ps_sq = dot(PS,PS);

  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0

                                                         // Important: if we want to write

                                                         // b = 1/a if a!=0, b=1 otherwise

                                                         // we need to write that as

                                                         // b = 1 / ( a-(sign(a)-1) )

                                                         // [ and NOT 1 / ( a + 1 - sign(a) ) ]

                                                         // because the latter, if 0<a<2^-24,

                                                         // will suffer from round-off error and in this case

                                                         // a + 1.0 = 1.0 !! so 1 / (a+1-sign(a)) = 1/0 !

  float DOT  = dot(PS,PO)*one_over_ps_sq;

  return 1.0 / (1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));

  }

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

// return min(degree_bitmap,degree_region). Just like degree_region, currently only supports circles.

float degree(in vec4 region, in vec2 S, in vec2 PS)

  {

  vec2 PO  = PS + region.xy;

  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2

  if( D<=0.0 ) return 0.0;

  vec2 A = sign(PS)*u_objD.xy + S;

  vec2 signA = sign(A);

  vec2 signA_SQ = signA*signA;

  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));

  float E = 1.0-max(div.x,div.y);

  float ps_sq = dot(PS,PS);

  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0

  float DOT  = dot(PS,PO)*one_over_ps_sq;

  return min(1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT)),E);

  }

#endif  // NUM_VERTEX>0

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

void main()

  {

  vec3 v = 2.0*u_objD*a_Position;

  vec3 n = a_Normal;

#if NUM_VERTEX>0

  int effect=0;

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

    {

    // ENABLED EFFECTS WILL BE INSERTED HERE

    effect+=3;

    }

#endif

  v_Position      = v;

  v_endPosition   = v + (0.3*u_objD.x)*n;

  v_TexCoordinate = a_TexCoordinate;

  v_Normal        = normalize(vec3(u_MVMatrix*vec4(n,0.0)));

  gl_Position     = u_MVPMatrix*vec4(v,1.0);

  }