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.Data1D;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

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

/**

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

 */

public class VertexEffectDeform extends VertexEffect

  {

  private static final EffectName NAME = EffectName.DEFORM;

  private final Data3D mVector, mCenter;

  private final Data1D mRadius;

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

    mRadius.get(uniforms,index+VALUES_OFFSET+3,currentDuration,step);

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

    }

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

// PUBLIC API

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

// Deform the whole shape of the Object by force V. Algorithm is as follows:

//

// Suppose we apply force (Vx,Vy) at point (Cx,Cy) (i.e. the center of the effect). Then, first of all,

// divide the rectangle into 4 smaller rectangles along the 1 horizontal + 1 vertical lines that pass

// through (Cx,Cy). Now suppose we have already understood the following case:

//

// A vertical (0,Vy) force applied to a rectangle (WxH) in size, at center which is the top-left corner

// of the rectangle.  (*)

//

// If we understand (*), then we understand everything, because in order to compute the movement of the

// whole rectangle we can apply (*) 8 times: for each one of the 4 sub-rectangles, apply (*) twice,

// once for the vertical component of the force vector, the second time for the horizontal one.

//

// Let's then compute (*):

// 1) the top-left point will move by exactly (0,Vy)

// 2) we arbitrarily decide that the top-right point will move by (|Vy|/(|Vy|+A*W))*Vy, where A is some

//    arbitrary constant (const float A below). The F(V,W) = (|Vy|/(|Vy|+A*W)) comes from the following:

//    a) we want F(V,0) = 1

//    b) we want lim V->inf (F) = 1

//    c) we actually want F() to only depend on W/V, which we have here.

// 3) then the top edge of the rectangle will move along the line Vy*G(x), where G(x) = (1 - (A*W/(|Vy|+A*W))*(x/W)^2)

// 4) Now we decide that the left edge of the rectangle will move along Vy*H(y), where H(y) = (1 - |y|/(|Vy|+C*|y|))

//    where C is again an arbitrary constant. Again, H(y) comes from the requirement that no matter how

//    strong we push the left edge of the rectangle up or down, it can never 'go over itself', but its

//    length will approach 0 if squeezed very hard.

// 5) The last point we need to compute is the left-right motion of the top-right corner (i.e. if we push

//    the top-left corner up very hard, we want to have the top-right corner not only move up, but also to

//    the left at least a little bit).

//    We arbitrarily decide that, in addition to moving up-down by Vy*F(V,W), the corner will also move

//    left-right by I(V,W) = B*W*F(V,W), where B is again an arbitrary constant.

// 6) combining 3), 4) and 5) together, we arrive at a movement of an arbitrary point (x,y) away from the

//    top-left corner:

//    X(x,y) = -B*x * (|Vy|/(|Vy|+A*W)) * (1-(y/H)^2)                               (**)

//    Y(x,y) = Vy * (1 - |y|/(|Vy|+C*|y|)) * (1 - (A*W/(|Vy|+A*W))*(x/W)^2)         (**)

//

// We notice that formulas (**) have been construed so that it is possible to continously mirror them

// left-right and up-down (i.e. apply not only to the 'bottom-right' rectangle of the 4 subrectangles

// but to all 4 of them!).

//

// Constants:

// a) A : valid values: (0,infinity). 'Bendiness' if the surface - the higher A is, the more the surface

//        bends. A<=0 destroys the system.

// b) B : valid values: <-1,1>. The amount side edges get 'sucked' inwards when we pull the middle of the

//        top edge up. B=0 --> not at all, B=1: a looot. B=-0.5: the edges will actually be pushed outwards

//        quite a bit. One can also set it to <-1 or >1, but it will look a bit ridiculous.

// c) C : valid values: <1,infinity). The derivative of the H(y) function at 0, i.e. the rate of 'squeeze'

//        surface gets along the force line. C=1: our point gets pulled very closely to points above it

//        even when we apply only small vertical force to it. The higher C is, the more 'uniform' movement

//        along the force line is.

//        0<=C<1 looks completely ridiculous and C<0 destroys the system.

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

// 2020-05-03: replaced vec3 'u_Bounding' with a uniform 'vUniforms[effect].w' (i.e. mRadius)

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

  static String code()

    {

    return

        "const vec3 ONE = vec3(1.0,1.0,1.0);                                 \n"

      + "const float A = 0.5;                                                \n"

      + "const float B = 0.2;                                                \n"

      + "const float C = 5.0;                                                \n"

      + "vec3 center = vUniforms[effect+1].yzw;                              \n"

      + "vec3 ps     = center-v;                                             \n"

      + "vec3 aPS    = abs(ps);                                              \n"

      + "vec3 maxps  = vUniforms[effect].w + abs(center);                    \n"

      + "float d     = degree(vUniforms[effect+2],ps);                       \n"

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

      + "vec3 aForce = abs(force);                                           \n"

      + "float denom = dot(ps+(1.0-d)*force,ps);                             \n"

      + "float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0));         \n"

      + "vec3 Aw = A*maxps;                                                  \n"

      + "vec3 quot = ps / maxps;                                             \n"

      + "quot = quot*quot;                                                   \n"  // ( (x/W)^2 , (y/H)^2 ) where x,y are distances from V to center

      + "float denomV = 1.0 / (aForce.y + Aw.x);                             \n"

      + "float denomH = 1.0 / (aForce.x + Aw.y);                             \n"

      + "vec3 vertCorr= ONE - aPS / ( aForce+C*aPS + (ONE-sign(aForce)) );   \n"  // avoid division by 0 when force and PS both are 0

      + "float mvXvert = -B * ps.x * aForce.y * (1.0-quot.y) * denomV;       \n"  // impact the vertical   component of the force vector has on horizontal movement

      + "float mvYhorz = -B * ps.y * aForce.x * (1.0-quot.x) * denomH;       \n"  // impact the horizontal component of the force vector has on vertical   movement

      + "float mvYvert = force.y * (1.0-quot.x*Aw.x*denomV) * vertCorr.y;    \n"  // impact the vertical   component of the force vector has on vertical   movement

      + "float mvXhorz = force.x * (1.0-quot.y*Aw.y*denomH) * vertCorr.x;    \n"  // impact the horizontal component of the force vector has on horizontal movement

      + "v.x += (mvXvert+mvXhorz);                                           \n"

      + "v.y += (mvYvert+mvYhorz);                                           \n"

      + "v.z += force.z*d*d*(3.0*d*d -8.0*d +6.0);                           \n"  // thick bubble

      + "float b = -(12.0*force.z*d*(1.0-d)*(1.0-d)*(1.0-d))*one_over_denom; \n"

      + "n.xy += n.z*b*ps.xy;                                                \n"

      + "n = normalize(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() );

    }

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

/**

 * Deform the whole Mesh with a (possibly changing in time) vector of force applied to

 * a (possibly changing in time) point on the Mesh.

 *

 * @param vector Vector of force that deforms the Mesh.

 * @param radius How 'bendy' the object is. Don';t set this to 0. Typically set this to the object's

 *               mesh size (i.e. more or less X of the rightmost vertex - X of the leftmost vertex)

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

 * @param region Region that masks the Effect.

 */

  public VertexEffectDeform(Data3D vector, Data1D radius, Data3D center, Data4D region)

    {

    super(NAME);

    mVector = vector;

    mRadius = radius;

    mCenter = center;

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

    }

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

/**

 * Deform the whole Mesh with a (possibly changing in time) vector of force applied to

 * a (possibly changing in time) point on the Mesh.

 *

 * @param vector Vector of force that deforms the Mesh.

 * @param radius How 'bendy' the object is. Don't set this to 0. Typically set this to the object's

 *               mesh size (i.e. more or less X of the rightmost vertex - X of the leftmost vertex)

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

 */

  public VertexEffectDeform(Data3D vector, Data1D radius, Data3D center)

    {

    super(NAME);

    mVector = vector;

    mRadius = radius;

    mCenter = center;

    mRegion = MAX_REGION;

    }

  }