Distorted Android

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

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

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

package org.distorted.library.effect;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

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

/**

 * Distort the Mesh by applying a 3D vector of force.

 */

public class VertexEffectDistort extends VertexEffect

  {

  private static final EffectName NAME = EffectName.DISTORT;

  private final Data3D mVector, mCenter;

  private final Data4D mRegion;

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public boolean compute(float[] uniforms, int index, long currentDuration, long step )

    {

    mCenter.get(uniforms,index+CENTER_OFFSET,currentDuration,step);

    mRegion.get(uniforms,index+REGION_OFFSET,currentDuration,step);

    return mVector.get(uniforms,index+VALUES_OFFSET,currentDuration,step);

    }

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

// PUBLIC API

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

// Def: P-current vertex being distorted, S - center of the effect, X- point where half-line SP meets

// the region circle (if P is inside the circle); (Vx,Vy,Vz) - force vector.

//

// horizontal part

// Point (Px,Py) gets moved by vector (Wx,Wy) where Wx/Wy = Vx/Vy i.e. Wx=aVx and Wy=aVy where

// a=Py/Sy (N --> when (Px,Py) is above (Sx,Sy)) or a=Px/Sx (W) or a=(w-Px)/(w-Sx) (E) or a=(h-Py)/(h-Sy) (S)

// It remains to be computed which of the N,W,E or S case we have: answer: a = min[ Px/Sx , Py/Sy , (w-Px)/(w-Sx) , (h-Py)/(h-Sy) ]

// Computations above are valid for screen (0,0)x(w,h) but here we have (-w/2,-h/2)x(w/2,h/2)

//

// vertical part

// Let vector PS = (dx,dy), f(x) (0<=x<=|SX|) be the shape of the side of the bubble.

// H(Px,Py) = |PS|>|SX| ? 0 : f(|PX|)

// N(Px,Py) = |PS|>|SX| ? (0,0,1) : ( -(dx/|PS|)sin(beta), -(dy/|PS|)sin(beta), cos(beta) ) where tan(beta) is f'(|PX|)

// ( i.e. normalize( dx, dy, -|PS|/f'(|PX|) )

//

// Now we also have to take into account the effect horizontal move by V=(Vx,Vy) will have on the normal vector.

// Solution:

// 1. Decompose the V into two subcomponents, one parallel to SX and another perpendicular.

// 2. Convince yourself (draw!) that the perpendicular component has no effect on normals.

// 3. The parallel component changes the length of |SX| by the factor of a=(|SX|-|Vpar|)/|SX| (where the length

//    can be negative depending on the direction)

// 4. that in turn leaves the x and y parts of the normal unchanged and multiplies the z component by a!

//

// |Vpar| = (Vx*dx-Vy*dy) / sqrt(ps_sq)  (-Vy because y is inverted)

// a =  (|SX| - |Vpar|)/|SX| = 1 - |Vpar|/((sqrt(ps_sq)/(1-d)) = 1 - (1-d)*|Vpar|/sqrt(ps_sq) = 1-(1-d)*(Vx*dx-Vy*dy)/ps_sq

//

// Side of the bubble

//

// choose from one of the three bubble shapes: the cone, the thin bubble and the thick bubble

// Case 1:

// f(t) = t, i.e. f(x) = Vz * x/|SX|   (a cone)

// -|PS|/f'(|PX|) = -|PS|*|SX|/Vz but since ps_sq=|PS|^2 and d=|PX|/|SX| then |PS|*|SX| = ps_sq/(1-d)

// so finally -|PS|/f'(|PX|) = -ps_sq/(Vz*(1-d))

//

// Case 2:

// f(t) = 3t^2 - 2t^3 --> f(0)=0, f'(0)=0, f'(1)=0, f(1)=1 (the bell curve)

// here we have t = x/|SX| which makes f'(|PX|) = 6*Vz*|PS|*|PX|/|SX|^3.

// so -|PS|/f'(|PX|) = (-|SX|^3)/(6Vz|PX|) =  (-|SX|^2) / (6*Vz*d) but

// d = |PX|/|SX| and ps_sq = |PS|^2 so |SX|^2 = ps_sq/(1-d)^2

// so finally -|PS|/f'(|PX|) = -ps_sq/ (6Vz*d*(1-d)^2)

//

// Case 3:

// f(t) = 3t^4-8t^3+6t^2 would be better as this satisfies f(0)=0, f'(0)=0, f'(1)=0, f(1)=1,

// f(0.5)=0.7 and f'(t)= t(t-1)^2 >=0 for t>=0 so this produces a fuller, thicker bubble!

// then -|PS|/f'(|PX|) = (-|PS|*|SX)) / (12Vz*d*(d-1)^2) but |PS|*|SX| = ps_sq/(1-d) (see above!)

// so finally -|PS|/f'(|PX|) = -ps_sq/ (12Vz*d*(1-d)^3)

//

// Now, new requirement: we have to be able to add up normal vectors, i.e. distort already distorted surfaces.

// If a surface is given by z = f(x,y), then the normal vector at (x0,y0) is given by (-df/dx (x0,y0), -df/dy (x0,y0), 1 ).

// so if we have two surfaces defined by f1(x,y) and f2(x,y) with their normals expressed as (f1x,f1y,1) and (f2x,f2y,1)

// then the normal to g = f1+f2 is simply given by (f1x+f2x,f1y+f2y,1), i.e. if the third components are equal, then we

// can simply add up the first and second components.

//

// Thus we actually want to compute N(Px,Py) = a*(-(dx/|PS|)*f'(|PX|), -(dy/|PS|)*f'(|PX|), 1) and keep adding

// the first two components. (a is the horizontal part)

//

// 2019-01-09 fixes for stuff discovered with the Earth testing app

// Now, the above stuff works only if the normal vector is close to (0,0,1). To make it work for any situation,

// rotate the normal, force and ps vectors along the axis (n.y,-n.x,0) and angle A between the normal and (0,0,1)

// then modify the rotated normal (so (0,0,1)) and rotate the modified normal back.

//

// if we have a vector (vx,vy,vz) that w want to rotate with a rotation that turns the normal into (0,0,1), then

// a) axis of rotation = (n.x,n.y,n.z) x (0,0,1) = (n.y,-n.x,0)

// b) angle of rotation A: cosA = (n.x,n.y,n.z)*(0,0,1) = n.z     (and sinA = + sqrt(1-n.z^2))

//

// so normalized axisNor = (n.x/ sinA, -n.y/sinA, 0) and now from Rodrigues rotation formula

// Vrot = v*cosA + (axisNor x v)*sinA + axisNor*(axis*v)*(1-cosA)

//

// which makes Vrot = (a+n.y*c , b-n.y*c , v*n) where

// a = vx*nz-vz*nx , b = vy*nz-vz*ny , c = (vx*ny-vy*nx)/(1+nz)    (unless n=(0,0,-1))

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

  static String code()

    {

    return

        "vec3 ps = vUniforms[effect+1].yzw - v;                        \n"

      + "vec3 force = vUniforms[effect].xyz;                           \n"

      + "vec4 region= vUniforms[effect+2];                             \n"

      + "float d = degree(region,ps);                                  \n"

      + "if( d>0.0 )                                                   \n"

      + "  {                                                           \n"

      + "  v += d*force;                                               \n"

      + "  float tp = 1.0+n.z;                                         \n"

      + "  float tr = 1.0 / (tp - (sign(tp)-1.0));                     \n"   // proper way to compute 1/x is

                                                                             // 1/(x-(sign(x)-1)) and NOT 1/(x+1-sign(x))

      + "  float ap = ps.x*n.z - ps.z*n.x;                             \n"   // rotate the ps vector

      + "  float bp = ps.y*n.z - ps.z*n.y;                             \n"   //

      + "  float cp =(ps.x*n.y - ps.y*n.x)*tr;                         \n"   //

      + "  vec3 psRot = vec3( ap+n.y*cp , bp-n.x*cp , dot(ps,n) );     \n"   //

      + "  float len = length(psRot);                                  \n"

      + "  float corr= sign(len)-1.0;                                  \n"   // make N (0,0,1) if ps=(0,0,0)

      + "  vec3 N = vec3( -dot(force,n)*psRot.xy, region.w*len-corr ); \n"   // modified rotated normal

                                                                             // dot(force,n) is rotated force.z

      + "  float an = N.x*n.z + N.z*n.x;                               \n"   // now create the normal vector

      + "  float bn = N.y*n.z + N.z*n.y;                               \n"   // back from our modified normal

      + "  float cn =(N.x*n.y - N.y*n.x)*tr;                           \n"   // rotated back

      + "  n = vec3( an+n.y*cn , bn-n.x*cn , -N.x*n.x-N.y*n.y+N.z*n.z);\n"   // notice 4 signs change!

      + "  n = normalize(n);                                           \n"

      + "  }";

    }

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

/**

 * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.

 */

  public static void enable()

    {

    addEffect( NAME, code() );

    }

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

/**

 * Distort a (possibly changing in time) part of the Mesh by a (possibly changing in time) vector of force.

 *

 * @param vector vector of force the Center of the Effect is currently being dragged with.

 * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.

 * @param region Region that masks the Effect.

 */

  public VertexEffectDistort(Data3D vector, Data3D center, Data4D region)

    {

    super(NAME);

    mVector = vector;

    mCenter = center;

    mRegion = (region==null ? MAX_REGION : region);

    }

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

/**

 * Distort the whole Mesh by a (possibly changing in time) vector of force.

 *

 * @param vector vector of force the Center of the Effect is currently being dragged with.

 * @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.

 */

  public VertexEffectDistort(Data3D vector, Data3D center)

    {

    super(NAME);

    mVector = vector;

    mCenter = center;

    mRegion = MAX_REGION;

    }

  }