Distorted Android

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

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

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

precision highp float;

precision highp int;

in vec3 a_Position;                   // Per-vertex position.

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

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

in float a_Component;                 // The component a vertex belongs to.

                                      // to a vertex effect. An effect will only be active on a vertex iff (a_Association & vAssociation[effect]) != 0.

                                      // ( see VertexEffect.retSection() )

out vec3 v_Position;                  // for Transform Feedback only

out vec3 v_endPosition;               // for Transform Feedback only

out vec3 v_Normal;                    //

out vec2 v_TexCoordinate;             //

uniform mat4 u_MVPMatrix;             // u_MVMatrixP * projection.

uniform mat4 u_MVMatrixP;             // the combined model/view matrix. (for points)

uniform mat4 u_MVMatrixV;             // the combined model/view matrix. (for vectors)

                                      // which need to work differently on points and vectors

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

uniform int u_TransformFeedback;      // are we doing the transform feedback now?

#ifdef COMP_CENTERS

layout (std140) uniform componentCenter

  {

  vec4 vComCenter[MAX_COMPON];        // centers of mesh components. 4 floats: (x,y,z,unused)

  };

#endif

#if NUM_VERTEX>0

uniform int vNumEffects;              // total number of vertex effects

layout (std140) uniform vUniformProperties

  {

  ivec4 vProperties[NUM_VERTEX];      // their properties, 4 ints:

                                      // 1: name of the effect

                                      // 2: effect's AND association

                                      // 3: reserved int (probably another AND assoc in the future)

                                      // 4: effect's EQU association

  };

layout (std140) uniform vUniformFloats

  {

  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,

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

  };

#ifdef BUGGY_UBOS

layout (packed) uniform componentAssociation

  {

  ivec2 vComAssoc[MAX_COMPON];        // component 'AND' and 'EQU' Associations

  };

#else

layout (std140) uniform componentAssociation

  {

  ivec4 vComAssoc[MAX_COMPON];        // component 'AND' and 'EQU' Associations

  };

#endif

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

// HELPER FUNCTIONS

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

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

//

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

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

// Let region.w be the radius of the region sphere.

// (This all should work regardless if S is inside or outside of the 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|)

// 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(in vec4 region, in vec3 PS)

  {

  float ps_sq = dot(PS,PS);

  if( ps_sq==0.0 ) return 1.0;

  vec3 PO = PS + region.xyz;

  float d = region.w*region.w-dot(PO,PO);

  if( d<=0.0 ) return 0.0;

  float b = dot(PS,PO)/ps_sq;

  return 1.0 / (1.0 + 1.0/(sqrt(b*b + d/ps_sq)-b));

  }

#endif  // NUM_VERTEX>0

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

void main()

  {

  int component = int(a_Component);

  vec3 n = a_Normal;

#ifdef COMP_CENTERS

  vec3 v = a_Position + u_Inflate*(a_Position - vComCenter[component].xyz);

#else

  vec3 v = a_Position + u_Inflate*a_Position;

#endif

#if NUM_VERTEX>0

  int effect=0;

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

    {

    if( ((vComAssoc[component].x & vProperties[i].y) != 0) || (vComAssoc[component].y == vProperties[i].w) )

      {

      // ENABLED EFFECTS WILL BE INSERTED HERE

      }

    effect+=3;

    }

#endif

#ifdef PREAPPLY

  v_Position   = v;

  v_endPosition= n;

#else

  if( u_TransformFeedback == 1 )

    {

    vec4 tmp1 =  u_MVMatrixP * vec4(v,1.0);

    vec4 tmp2 =  normalize(u_MVMatrixV * vec4(n,0.0));

    v_Position    = vec3(tmp1);

    v_endPosition = vec3(tmp1+100.0*tmp2);

    }

  else

    {

    v_Position = v;

    }

#endif

  v_TexCoordinate = a_TexCoordinate;

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

  gl_Position     = u_MVPMatrix*vec4(v,1.0);

  }