Distorted Android

package org.distorted.library;

import java.util.Random;

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

/** A class to interpolate between a List of Float{1,2,3,4}Ds.

* <p><ul>

* <li>if there is only one Point, just jump to it.

* <li>if there are two Points, linearly bounce between them

* <li>if there are more, interpolate a loop (or a path!) between them.

* </ul>

*/

// The way Interpolation between more than 2 Points is done:

// 

// Def: let w[i] = (w[i](x), w[i](y), w[i](z)) be the direction and speed we have to be flying at Point P[i]

//

// time it takes to fly though one segment v[i] --> v[i+1] : 0.0 --> 1.0

// w[i] should be parallel to v[i+1] - v[i-1]   (cyclic notation)

// |w[i]| proportional to | P[i]-P[i+1] |

//

// Given that the flight route (X(t), Y(t), Z(t)) from P(i) to P(i+1)  (0<=t<=1) has to satisfy

// X(0) = P[i  ](x), Y(0)=P[i  ](y), Z(0)=P[i  ](z), X'(0) = w[i  ](x), Y'(0) = w[i  ](y), Z'(0) = w[i  ](z)

// X(1) = P[i+1](x), Y(1)=P[i+1](y), Z(1)=P[i+1](z), X'(1) = w[i+1](x), Y'(1) = w[i+1](y), Z'(1) = w[i+1](z)

//

// we have the solution:  X(t) = at^3 + bt^2 + ct + d where

// a =  2*P[i](x) +   w[i](x) - 2*P[i+1](x) + w[i+1](x)

// b = -3*P[i](x) - 2*w[i](x) + 3*P[i+1](x) - w[i+1](x)

// c = w[i](x)<br>

// d = P[i](x)

//

// and similarly Y(t) and Z(t).

public abstract class Interpolator 

  {

  /**

   * One revolution takes us from the first vector to the last and back to first through the shortest path. 

   */

  public static final int MODE_LOOP = 0; 

  /**

   * We come back from the last to the first vector through the same way we got there.

   */

  public static final int MODE_PATH = 1; 

  /**

   * We just jump back from the last point to the first.

   */

  public static final int MODE_JUMP = 2; 

  protected static Random mRnd = new Random();

  protected static final int NUM_NOISE = 5; // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors

                                            // where we randomize noise factors to make the way between the two vectors not so smooth.

  protected int numPoints;

  protected int mVecCurr;    

  protected boolean cacheDirty; // VectorCache not up to date

  protected int mMode;          // LOOP, PATH or JUMP

  protected long mDuration;     // number of miliseconds it takes to do a full loop/path from first vector to the last and back to the first 

  protected float mCount;       // number of loops/paths we will do; mCount = 1.5 means we go from the first vector to the last, back to first, and to the last again. 

  protected float mNoise;       // how 'smooth' our path form each vector to the next is. mNoise = 0.0 (min) --> completely smooth; mNoise==1.0 (max) --> very uneven

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

// hide this from Javadoc

  Interpolator()

    {

    }

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

  void interpolateMain(float[] buffer, int offset, long currentDuration)

    {

    if( mDuration<=0.0f ) 

      {

      interpolate(buffer,offset,mCount-(int)mCount);  

      }

    else

      {

      float x = (float)currentDuration/mDuration;

      if( x<=mCount || mCount<=0.0f )

        {

        interpolate(buffer,offset,x-(int)x);

        }

      }

    }

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

  boolean interpolateMain(float[] buffer, int offset, long currentDuration, long step)

    {

    if( mDuration<=0.0f ) 

      {

      interpolate(buffer,offset,mCount-(int)mCount);

      return false;

      }

    float x = (float)currentDuration/mDuration;

    if( x<=mCount || mCount<=0.0f )

      {

      interpolate(buffer,offset,x-(int)x);

      if( currentDuration+step > mDuration*mCount && mCount>0.0f )

        {

        interpolate(buffer,offset,mCount-(int)mCount);

        return true;

        }

      }

    return false;

    }

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

// internal debugging only!

  String print()

    {

    return "duration="+mDuration+" count="+mCount+" Noise="+mNoise+" numVectors="+numPoints+" mMode="+mMode;

    }

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

  abstract void interpolate(float[] buffer, int offset, float time);

  abstract void createNoise();

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

// PUBLIC API

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

/**

 * Sets the mode of the interpolation to Loop, Path or Jump.

 * <ul>

 * <li>Loop is when we go from the first point all the way to the last, and the back to the first through 

 * the shortest way.

 * <li>Path is when we come back from the last point back to the first the same way we got there.

 * <li>Jump is when we go from first to last and then jump back to the first.

 * </ul>

 * 

 * @param mode {@link Interpolator#MODE_LOOP}, {@link Interpolator#MODE_PATH} or {@link Interpolator#MODE_JUMP}.

 */

  public void setMode(int mode)

    {

    mMode = mode;  

    }

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

/**

 * Returns the number of Float{1,2,3,4}Ds this Interpolator has been fed with.

 *   

 * @return the number of Float{1,2,3,4}Ds we are currently interpolating through.

 */

  public synchronized int getNumPoints()

    {

    return numPoints;  

    }

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

/**

 * Controls how many times we want to interpolate.

 * <p>

 * Count equal to 1 means 'go from the first Float{1,2,3,4}D to the last and back'. Does not have to be an

 * integer - i.e. count=1.5 would mean 'start at the first Point, go to the last, come back to the first, 

 * go to the last again and stop'.

 * Count<=0 means 'go on interpolating indefinitely'.

 * 

 * @param count the number of times we want to interpolate between our collection of Float{1,2,3,4}Ds.

 */

  public void setCount(float count)

    {

    mCount = count;  

    }

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

/**

 * Sets the time it takes to do one full interpolation.

 * 

 * @param duration Time, in milliseconds, it takes to do one full interpolation, i.e. go from the first 

 *                 Point to the last and back. 

 */

  public void setDuration(long duration)

    {

    mDuration = duration;

    }

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

/**

 * Sets the 'smoothness' of interpolation. 

 * <p>

 * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. 

 * Increasing noise makes the Interpolator increasingly deviate from this path, pseudo-randomly speeding 

 * up and slowing down, etc.

 * 

 * @param noise The noise level. Permitted range: 0 <= noise <= 1.

 */

  public void setNoise(float noise)

    {

    if( mNoise==0.0f && noise != 0.0f )  

      createNoise();

    if( mNoise<0.0f ) mNoise = 0.0f;

    if( mNoise>1.0f ) mNoise = 1.0f;

    mNoise = noise;

    }

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

// end of DistortedInterpolator

  }