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;

import org.distorted.library.type.Data5D;

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

/**

 * Directional, sinusoidal wave effect.

 *

 * Not a fully 3D effect. To achieve a fully 3D one we'd need another parameter making the whole thing

 * a 6D effect but there's no room in the Vertex Uniforms which assign only 5 floats for interpolated

 * effect values. Rethink this. ATM fully enough for 2.5D meshes like the MeshCubes.

 */

public class VertexEffectWave extends VertexEffect

  {

  private static final EffectName NAME = EffectName.WAVE;

  private final Data5D mWave;

  private final Data3D 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);

    boolean ret = mWave.get(uniforms,index+VALUES_OFFSET,currentDuration,step);

    uniforms[index+VALUES_OFFSET+2] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+2]/180);

    uniforms[index+VALUES_OFFSET+3] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+3]/180);

    uniforms[index+VALUES_OFFSET+4] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+4]/180);

    return ret;

    }

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

// Directional sinusoidal wave effect.

//

// This is an effect from a (hopefully!) generic family of effects of the form (vec3 V: |V|=1 , f(x,y) )  (*)

// i.e. effects defined by a unit vector and an arbitrary function. Those effects are defined to move each

// point (x,y,0) of the XY plane to the point (x,y,0) + V*f(x,y).

//

// In this case V is defined by angles A and B (sines and cosines of which are precomputed in

// EffectQueueVertex and passed in the uniforms).

// Let's move V to start at the origin O, let point C be the endpoint of V, and let C' be C's projection

// to the XY plane. Then A is defined to be the angle C0C' and angle B is the angle C'O(axisY).

//

// Also, in this case f(x,y) = amplitude*sin(x/length), with those 2 parameters passed in uniforms.

//

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

// How to compute any generic effect of type (*)

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

//

// By definition, the vertices move by f(x,y)*V.

//

// Normals are much more complicated.

// Let angle X be the angle (0,Vy,Vz)(0,Vy,0)(Vx,Vy,Vz).

// Let angle Y be the angle (Vx,0,Vz)(Vx,0,0)(Vx,Vy,Vz).

//

// Then it can be shown that the resulting surface, at point to which point (x0,y0,0) got moved to,

// has 2 tangent vectors given by

//

// SX = (1.0+cosX*fx , cosY*sinX*fx , |sinY|*sinX*fx);  (**)

// SY = (cosX*sinY*fy , 1.0+cosY*fy , |sinX|*sinY*fy);  (***)

//

// and then obviously the normal N is given by N= SX x SY .

//

// We still need to remember the note from the distort function dialog_about adding up normals:

// we first need to 'normalize' the normals to make their third components equal, and then we

// simply add up the first and the second component while leaving the third unchanged.

//

// How to see facts (**) and (***) ? Briefly:

// a) compute the 2D analogon and conclude that in this case the tangent SX is given by

//    SX = ( cosA*f'(x) +1, sinA*f'(x) )    (where A is the angle vector V makes with X axis )

// b) cut the resulting surface with plane P which

//    - includes vector V

//    - crosses plane XY along line parallel to X axis

// c) apply the 2D analogon and notice that the tangent vector to the curve that is the common part of P

//    and our surface (I am talking dialog_about the tangent vector which belongs to P) is given by

//    (1+cosX*fx,0,sinX*fx) rotated by angle (90-|Y|) (where angles X,Y are defined above) along vector (1,0,0).

//

//    Matrix of rotation:

//

//    |sinY|  cosY

//    -cosY  |sinY|

//

// d) compute the above and see that this is equal precisely to SX from (**).

// e) repeat points b,c,d in direction Y and come up with (***).

//

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

// Note: we should avoid passing certain combinations of parameters to this function. One such known

// combination is ( A: small but positive, B: any, amplitude >= length ).

// In this case, certain 'unlucky' points have their normals almost horizontal (they got moved by (almost!)

// amplitude, and other point length (i.e. <=amplitude) away got moved by 0, so the slope in this point is

// very steep). Visual effect is: vast majority of surface pretty much unchanged, but random 'unlucky'

// points very dark)

//

// Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.

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

  static String code()

    {

    return

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

      + "float amplitude = vUniforms[effect  ].x;                     \n"

      + "float length    = vUniforms[effect  ].y;                     \n"

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

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

      + "if( deg != 0.0 && length != 0.0 )                            \n"

      +   "{                                                          \n"

      +   "float phase = vUniforms[effect  ].z;                       \n"

      +   "float alpha = vUniforms[effect  ].w;                       \n"

      +   "float beta  = vUniforms[effect+1].x;                       \n"

      +   "float sinA = sin(alpha);                                   \n"

      +   "float cosA = cos(alpha);                                   \n"

      +   "float sinB = sin(beta);                                    \n"

      +   "float cosB = cos(beta);                                    \n"

      +   "float angle= 1.578*(ps.x*cosB-ps.y*sinB) / length + phase; \n"

      +   "vec3 dir= vec3(sinB*cosA,cosB*cosA,sinA);                  \n"

      +   "v += sin(angle)*deg*dir;                                   \n"

      +   "if( n.z != 0.0 )                                           \n"

      +     "{                                                        \n"

      +     "float sqrtX = sqrt(dir.y*dir.y + dir.z*dir.z);           \n"

      +     "float sqrtY = sqrt(dir.x*dir.x + dir.z*dir.z);           \n"

      +     "float sinX = ( sqrtY==0.0 ? 0.0 : dir.z / sqrtY);        \n"

      +     "float cosX = ( sqrtY==0.0 ? 1.0 : dir.x / sqrtY);        \n"

      +     "float sinY = ( sqrtX==0.0 ? 0.0 : dir.z / sqrtX);        \n"

      +     "float cosY = ( sqrtX==0.0 ? 1.0 : dir.y / sqrtX);        \n"

      +     "float abs_z = dir.z <0.0 ? -(sinX*sinY) : (sinX*sinY);   \n"

      +     "float tmp = 1.578*cos(angle)*deg/length;                 \n"

      +     "float fx =-cosB*tmp;                                     \n"

      +     "float fy = sinB*tmp;                                     \n"

      +     "vec3 sx = vec3 (1.0+cosX*fx,cosY*sinX*fx,abs_z*fx);      \n"

      +     "vec3 sy = vec3 (cosX*sinY*fy,1.0+cosY*fy,abs_z*fy);      \n"

      +     "vec3 normal = cross(sx,sy);                              \n"

      +     "if( normal.z<=0.0 )                                      \n"   // Why this bizarre thing rather than the straightforward

      +       "{                                                      \n"   //

      +       "normal.x= 0.0;                                         \n"   // if( normal.z>0.0 )

      +       "normal.y= 0.0;                                         \n"   //   {

      +       "normal.z= 1.0;                                         \n"   //   n.x = (n.x*normal.z + n.z*normal.x);

      +       "}                                                      \n"   //   n.y = (n.y*normal.z + n.z*normal.y);

                                                                            //   n.z = (n.z*normal.z);

                                                                            //   }

      +     "n.x = (n.x*normal.z + n.z*normal.x);                     \n"   //

      +     "n.y = (n.y*normal.z + n.z*normal.y);                     \n"   // ? Because if we do the above, my Nexus4 crashes

      +     "n.z = (n.z*normal.z);                                    \n"   // during shader compilation!

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

      +     "}                                                        \n"

      +   "}";

    }

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

// PUBLIC API

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

/**

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

    }

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

/**

 * Directional, sinusoidal wave effect.

 *

 * @param wave   A 5-dimensional data structure describing the wave: first member is the amplitude,

 *               second is the wave length, third is the phase (i.e. when phase = PI/2, the sine

 *               wave at the center does not start from sin(0), but from sin(PI/2) ) and the next two

 *               describe the 'direction' of the wave.

 *               <p>

 *               Wave direction is defined to be a 3D vector of length 1. To define such vectors, we

 *               need 2 floats: thus the fourth member is the angle Alpha (in degrees) which the vector

 *               forms with the XY-plane, and the fifth is the angle Beta (again in degrees) which

 *               the projection of the vector to the XY-plane forms with the Y-axis (counterclockwise).

 *               <p>

 *               <p>

 *               Example1: if Alpha = 90, Beta = 90, (then V=(0,0,1) ) and the wave acts 'vertically'

 *               in the X-direction, i.e. cross-sections of the resulting surface with the XZ-plane

 *               will be sine shapes.

 *               <p>

 *               Example2: if Alpha = 90, Beta = 0, the again V=(0,0,1) and the wave is 'vertical',

 *               but this time it waves in the Y-direction, i.e. cross sections of the surface and the

 *               YZ-plane with be sine shapes.

 *               <p>

 *               Example3: if Alpha = 0 and Beta = 45, then V=(sqrt(2)/2, sqrt(2)/2, 0) and the wave

 *               is entirely 'horizontal' and moves point (x,y,0) in direction V by whatever is the

 *               value if sin at this point.

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

 * @param region Region that masks the Effect.

 */

  public VertexEffectWave(Data5D wave, Data3D center, Data4D region)

    {

    super(NAME);

    mWave   = wave;

    mCenter = center;

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

    }

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

/**

 * Directional, sinusoidal wave effect.

 *

 * @param wave   see {@link #VertexEffectWave(Data5D,Data3D,Data4D)}

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

 */

  public VertexEffectWave(Data5D wave, Data3D center)

    {

    super(NAME);

    mWave   = wave;

    mCenter = center;

    mRegion = MAX_REGION;

    }

  }