Distorted Android

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

// Copyright 2017 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted 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 General Public License for more details.                                                  //

//                                                                                               //

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

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.library.effect;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

import org.distorted.library.type.Data5D;

import org.distorted.library.type.Static4D;

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

public class VertexEffectWave extends VertexEffect

  {

  private Data5D mWave;

  private Data3D mCenter;

  private Data4D mRegion;

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

/**

 * 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 third member is the angle Alpha (in degrees) which the vector

 *               forms with the XY-plane, and the fourth 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(EffectName.WAVE);

    mWave   = wave;

    mCenter = center;

    mRegion = (region==null ? new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE) : region);

    }

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

/**

 * Directional, sinusoidal wave effect.

 *

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

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

 */

  public VertexEffectWave(Data5D wave, Data3D center)

    {

    super(EffectName.WAVE);

    mWave   = wave;

    mCenter = center;

    mRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);

    }

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

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

    {

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

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

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

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

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

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

    uniforms[index+9] =-uniforms[index+9];

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

  public static void enable()

    {

    addEffect(EffectName.WAVE,

        "vec2 center     = vUniforms[effect+1].yz; \n"

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

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

      + "vec2 ps = center - v.xy; \n"

      + "float deg = amplitude*degree_region(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 shit 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 shitty Nexus4 crashes

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

      +     "} \n"

      +   "}"

      );

    }

  }