Distorted Android

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

// DistortedLibrary is distributed in the hope that it will be useful,                             //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //

// along with DistortedLibrary.  If not, see <http://www.gnu.org/licenses/>.                       //

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

precision highp float;

precision highp int;

in vec3 a_Position;                  // Per-vertex position.

in vec3 a_Inflate;                   // This vector describes the direction this vertex needs to go when we 'inflate' the whole mesh.

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

out vec3 v_Position;                 //

out vec3 v_endPosition;              // for Transform Feedback only

out vec3 v_Normal;                   //

uniform vec3 u_Bounding;             // MeshBase.mBounding{X,Y,Z}

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

uniform float u_Inflate;             // how much should we inflate (>0.0) or deflate (<0.0) the mesh.

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

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

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

//

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

// d = min(t,h);

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

//

// We still have to avoid division by 0 when p.x = +- u_Bounding.x or p.y = +- u_Bounding.y (i.e

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

// 2019-01-09: make this 3D. The trick: we want only the EDGES of the cuboid to stay constant.

// the interiors of the Faces move! Thus, we want the MIDDLE of the PS/(sign(PS)*u_Bounding+S) !

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

// return degree of the point as defined by the cuboid (u_Bounding.x X u_Bounding.y X u_Bounding.z)

float degree_object(in vec3 S, in vec3 PS)

  {

  vec3 ONE = vec3(1.0,1.0,1.0);

  vec3 A = sign(PS)*u_Bounding + S;

  vec3 signA = sign(A);                      //

  vec3 ret = sign(u_Bounding)-div;

  float d1= ret.x-ret.y;

  if( d1*d2>0.0 ) return ret.y;             //

  }

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

//

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

//

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

//

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

// Otherwise, let X be the point where the halfline SP meets the sphere - 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|)

float degree_region(in vec4 region, in vec3 PS)

  {

  vec3 PO  = PS + region.xyz;

  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 1.0 / (1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));

  }

// return min(degree_object,degree_region). Just like degree_region, currently only supports spheres.

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

  {

  vec3 PO  = PS + region.xyz;

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

  vec3 A = sign(PS)*u_Bounding + S;

  vec3 signA = sign(A);

  vec3 ret = sign(u_Bounding)-div;            // if object is flat, make ret.z 0

  float d1= ret.x-ret.y;

       if( d1*d2>0.0 ) degree_object= ret.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;

  float degree_region = 1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));

  return min(degree_region,degree_object);

  }

#endif  // NUM_VERTEX>0

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

  vec3 v = u_Stretch*a_Position;

  vec3 n = a_Normal;

  v += u_Inflate*u_Stretch*a_Inflate;

#if NUM_VERTEX>0

  int effect=0;

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

    // ENABLED EFFECTS WILL BE INSERTED HERE

    effect+=3;

    }

  v_Position      = v;

  v_endPosition   = v + (0.2*u_Stretch.x)*n;

  v_TexCoordinate = a_TexCoordinate;

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

  gl_Position     = u_MVPMatrix*vec4(v,1.0);

  }