Distorted Android

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

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

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

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

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

// on the edge of the Object).

// 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 signA_SQ = signA*signA;               // div = PS/A if A!=0, 0 otherwise.

  vec3 div = signA_SQ*PS/(A-(ONE-signA_SQ)); //

  vec3 ret = sign(u_Bounding)-div;

  float d1= ret.x-ret.y;

  float d2= ret.y-ret.z;

  float d3= ret.x-ret.z;

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

  if( d1*d3>0.0 ) return ret.z;             // return 1-middle(div.x,div.y,div.z)

  return ret.x;                             // (unless size of object is 0 then 0-middle)

  }

float degree_region(in vec4 region, in vec3 PS)

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

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

  if( D<=0.0 ) return 0.0;

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

  vec3 signA = sign(A);

  vec3 signA_SQ = signA*signA;

  vec3 div = signA_SQ*PS/(A-(vec3(1.0,1.0,1.0)-signA_SQ));

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

  float d1= ret.x-ret.y;

  float d2= ret.y-ret.z;

  float d3= ret.x-ret.z;

  float degree_object;

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

  else if( d1*d3>0.0 ) degree_object= ret.z;  // middle of the ret.{x,y,z} triple

  else                 degree_object= ret.x;  //

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

  }