Distorted Android

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

// Copyright 2016 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.type;

import java.util.Random;

import java.util.Vector;

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

/** A class to interpolate between a list of Statics.

* <p><ul>

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

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

* <li>if there are more, interpolate a path between them. Exact way we interpolate depends on the MODE.

* </ul>

*/

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

// 

// Def: let V[i] = (V[i](x), V[i](y), V[i](z)) be the direction and speed (i.e. velocity) we have to

// be flying at Point P[i]

//

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

//

// We arbitrarily decide that V[i] should be equal to (|curr|*prev + |prev|*curr) / min(|prev|,|curr|)

// where prev = P[i]-P[i-1] and curr = P[i+1]-P[i]

//

// 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) = V[i  ](x), Y'(0) = V[i  ](y), Z'(0) = V[i  ](z)

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

//

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

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

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

// c =                V[i](x)

// d =    P[i](x)

//

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

public abstract class Dynamic

  {

  /**

   * Keep the speed of interpolation always changing. Time to cover one segment (distance between

   * two consecutive points) always the same. Smoothly interpolate the speed between two segments.

   */

  public static final int SPEED_MODE_SMOOTH            = 0;

  /**

   * Make each segment have constant speed. Time to cover each segment is still the same, thus the

   * speed will jump when passing through a point and then keep constant.

   */

  public static final int SPEED_MODE_SEGMENT_CONSTANT  = 1;

  /**

   * Have the speed be always, globally the same across all segments. Time to cover one segment will

   * thus generally no longer be the same.

   */

  public static final int SPEED_MODE_GLOBALLY_CONSTANT = 2;  // TODO: not supported yet

  /**

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

   */

  public static final int MODE_LOOP = 0; 

  /**

   * One revolution takes us from the first point to the last and back to first through the same path.

   */

  public static final int MODE_PATH = 1; 

  /**

   * One revolution takes us from the first point to the last and jumps straight back to the first point.

   */

  public static final int MODE_JUMP = 2; 

  /**

   * The default mode of access. When in this mode, we are able to call interpolate() with points in time

   * in any random order. This means one single Dynamic can be used in many effects simultaneously.

   * On the other hand, when in this mode, it is not possible to smoothly interpolate when mDuration suddenly

   * changes.

   */

  public static final int ACCESS_TYPE_RANDOM     = 0;

  /**

   * Set the mode to ACCESS_SEQUENTIAL if you need to change mDuration and you would rather have the Dynamic

   * keep on smoothly interpolating.

   * On the other hand, in this mode, a Dynamic can only be accessed in sequential manner, which means one

   * Dynamic can only be used in one effect at a time.

   */

  public static final int ACCESS_TYPE_SEQUENTIAL = 1;

  protected int mDimension;

  protected int numPoints;

  protected int mSegment;       // between which pair of points are we currently? (in case of PATH this is a bit complicated!)

  protected boolean cacheDirty; // VectorCache not up to date

  protected int mMode;          // LOOP, PATH or JUMP

  protected long mDuration;     // number of milliseconds 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 double mLastPos;

  protected int mAccessType;

  protected int mSpeedMode;

  protected float mTmpTime;

  protected int mTmpVec, mTmpSeg;

  protected class VectorNoise

    {

    float[][] n;

    VectorNoise()

      {

      n = new float[mDimension][NUM_NOISE];

      }

    void computeNoise()

      {

      n[0][0] = mRnd.nextFloat();

      for(int i=1; i<NUM_NOISE; i++) n[0][i] = n[0][i-1]+mRnd.nextFloat();

      float sum = n[0][NUM_NOISE-1] + mRnd.nextFloat();

      for(int i=0; i<NUM_NOISE; i++)

        {

        n[0][i] /=sum;

        for(int j=1; j<mDimension; j++) n[j][i] = mRnd.nextFloat()-0.5f;

        }

      }

    }

  protected Vector<VectorNoise> vn;

  protected float[] mFactor;

  protected float[] mNoise;

  protected float[][] baseV;

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

  // the coefficients of the X(t), Y(t) and Z(t) polynomials: X(t) = a[0]*T^3 + b[0]*T^2 + c[0]*t + d[0]  etc.

  // (velocity) is the velocity vector.

  // (cached) is the original vector from vv (copied here so when interpolating we can see if it is

  // still valid and if not - rebuild the Cache

  protected class VectorCache

    {

    float[] a;

    float[] b;

    float[] c;

    float[] d;

    float[] velocity;

    float[] cached;

    float[] path_ratio;

    VectorCache()

      {

      a = new float[mDimension];

      b = new float[mDimension];

      c = new float[mDimension];

      d = new float[mDimension];

      velocity   = new float[mDimension];

      cached     = new float[mDimension];

      path_ratio = new float[NUM_RATIO];

      }

    }

  protected Vector<VectorCache> vc;

  protected VectorCache tmpCache1, tmpCache2;

  protected float mConvexity;

  private static final int NUM_RATIO = 10; // we attempt to 'smooth out' the speed in each segment -

                                           // remember this many 'points' inside the Cache for each segment.

  protected static final float[] mTmpRatio = new float[NUM_RATIO];

  private float[] buf;

  private float[] old;

  private static final Random mRnd = new Random();

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

  private long mStartTime;

  private long mCorrectedTime;

  private static long mPausedTime;

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

// hide this from Javadoc

  protected Dynamic()

    {

    }

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

  protected Dynamic(int duration, float count, int dimension)

    {

    vc         = new Vector<>();

    vn         = null;

    numPoints  = 0;

    cacheDirty = false;

    mMode      = MODE_LOOP;

    mDuration  = duration;

    mCount     = count;

    mDimension = dimension;

    mSegment   = -1;

    mLastPos   = -1;

    mAccessType= ACCESS_TYPE_RANDOM;

    mSpeedMode = SPEED_MODE_SMOOTH;

    mConvexity = 1.0f;

    mStartTime = -1;

    mCorrectedTime = 0;

    baseV      = new float[mDimension][mDimension];

    buf        = new float[mDimension];

    old        = new float[mDimension];

    }

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

  void initDynamic()

    {

    mStartTime = -1;

    mCorrectedTime = 0;

    }

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

  public static void onPause()

    {

    mPausedTime = System.currentTimeMillis();

    }

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

  protected void computeSegmentAndTime(float time)

    {

    switch(mMode)

      {

      case MODE_LOOP: mTmpTime= time*numPoints;

                      mTmpSeg = (int)mTmpTime;

                      mTmpVec = mTmpSeg;

                      break;

      case MODE_PATH: mTmpSeg = (int)(2*time*(numPoints-1));

                      if( time<=0.5f )  // this has to be <= (otherwise when effect ends at t=0.5, then time=1.0

                        {               // and end position is slightly not equal to the end point => might not get autodeleted!

                        mTmpTime = 2*time*(numPoints-1);

                        mTmpVec = mTmpSeg;

                        }

                      else

                        {

                        mTmpTime = 2*(1-time)*(numPoints-1);

                        mTmpVec  = 2*numPoints-3-mTmpSeg;

                        }

                      break;

      case MODE_JUMP: mTmpTime= time*(numPoints-1);

                      mTmpSeg = (int)mTmpTime;

                      mTmpVec = mTmpSeg;

                      break;

      default       : mTmpVec = 0;

                      mTmpSeg = 0;

      }

    }

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

  private float valueAtPoint(float t, VectorCache cache)

    {

    float tmp,sum = 0.0f;

    for(int d=0; d<mDimension; d++)

      {

      tmp = (3*cache.a[d]*t + 2*cache.b[d])*t + cache.c[d];

      sum += tmp*tmp;

      }

    return (float)Math.sqrt(sum);

    }

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

  protected float smoothSpeed(float time, VectorCache cache)

    {

    float fndex = time*NUM_RATIO;

    int index = (int)fndex;

    float prev = index==0 ? 0.0f : cache.path_ratio[index-1];

    float next = cache.path_ratio[index];

    return prev + (next-prev)*(fndex-index);

    }

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

// First, compute the approx length of the segment from time=0 to time=(i+1)/NUM_TIME and store this

// in cache.path_ratio[i]. Then the last path_ratio is the length from 0 to 1, i.e. the total length

// of the segment.

// We do this by computing the integral from 0 to 1 of sqrt( (dx/dt)^2 + (dy/dt)^2 ) (i.e. the length

// of the segment) using the approx 'trapezoids' integration method.

//

// Then, for every i, divide path_ratio[i] by the total length to get the percentage of total path

// length covered at time i. At this time, path_ratio[3] = 0.45 means 'at time 3/NUM_RATIO, we cover

// 0.45 = 45% of the total length of the segment.

//

// Finally, invert this function (for quicker lookups in smoothSpeed) so that after this step,

// path_ratio[3] = 0.45 means 'at 45% of the time, we cover 3/NUM_RATIO distance'.

  protected void smoothOutSegment(VectorCache cache)

    {

    float vPrev, sum = 0.0f;

    float vNext = valueAtPoint(0.0f,cache);

    for(int i=0; i<NUM_RATIO; i++)

      {

      vPrev = vNext;

      vNext = valueAtPoint( (float)(i+1)/NUM_RATIO,cache);

      sum += (vPrev+vNext);

      cache.path_ratio[i] = sum;

      }

    float total = cache.path_ratio[NUM_RATIO-1];

    for(int i=0; i<NUM_RATIO; i++) cache.path_ratio[i] /= total;

    int writeIndex = 0;

    float prev=0.0f, next, ratio= 1.0f/NUM_RATIO;

    for(int readIndex=0; readIndex<NUM_RATIO; readIndex++)

      {

      next = cache.path_ratio[readIndex];

      while( prev<ratio && ratio<=next )

        {

        float a = (next-ratio)/(next-prev);

        mTmpRatio[writeIndex] = (readIndex+1-a)/NUM_RATIO;

        writeIndex++;

        ratio = (writeIndex+1.0f)/NUM_RATIO;

        }

      prev = next;

      }

    System.arraycopy(mTmpRatio, 0, cache.path_ratio, 0, NUM_RATIO);

    }

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

  protected float noise(float time,int vecNum)

    {

    float lower, upper, len;

    float d = time*(NUM_NOISE+1);

    int index = (int)d;

    if( index>=NUM_NOISE+1 ) index=NUM_NOISE;

    VectorNoise tmpN = vn.elementAt(vecNum);

    float t = d-index;

    t = t*t*(3-2*t);

    switch(index)

      {

      case 0        : for(int i=0;i<mDimension-1;i++) mFactor[i] = mNoise[i+1]*tmpN.n[i+1][0]*t;

                      return time + mNoise[0]*(d*tmpN.n[0][0]-time);

      case NUM_NOISE: for(int i=0;i<mDimension-1;i++) mFactor[i] = mNoise[i+1]*tmpN.n[i+1][NUM_NOISE-1]*(1-t);

                      len = ((float)NUM_NOISE)/(NUM_NOISE+1);

                      lower = len + mNoise[0]*(tmpN.n[0][NUM_NOISE-1]-len);

                      return (1.0f-lower)*(d-NUM_NOISE) + lower;

      default       : float ya,yb;

                      for(int i=0;i<mDimension-1;i++)

                        {

                        yb = tmpN.n[i+1][index  ];

                        ya = tmpN.n[i+1][index-1];

                        mFactor[i] = mNoise[i+1]*((yb-ya)*t+ya);

                        }

                      len = ((float)index)/(NUM_NOISE+1);

                      lower = len + mNoise[0]*(tmpN.n[0][index-1]-len);

                      len = ((float)index+1)/(NUM_NOISE+1);

                      upper = len + mNoise[0]*(tmpN.n[0][index  ]-len);

                      return (upper-lower)*(d-index) + lower;

      }

    }

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

// debugging only

  private void printBase(String str)

    {

    String s;

    float t;

    for(int i=0; i<mDimension; i++)

      {

      s = "";

      for(int j=0; j<mDimension; j++)

        {

        t = ((int)(1000*baseV[i][j]))/(1000.0f);

        s+=(" "+t);

        }

      android.util.Log.e("dynamic", str+" base "+i+" : " + s);

      }

    }

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

// debugging only

  @SuppressWarnings("unused")

  private void checkBase()

    {

    float tmp, cosA;

    float[] len= new float[mDimension];

    boolean error=false;

    for(int i=0; i<mDimension; i++)

      {

      len[i] = 0.0f;

      for(int k=0; k<mDimension; k++)

        {

        len[i] += baseV[i][k]*baseV[i][k];

        }

      if( len[i] == 0.0f || len[0]/len[i] < 0.95f || len[0]/len[i]>1.05f )

        {

        android.util.Log.e("dynamic", "length of vector "+i+" : "+Math.sqrt(len[i]));

        error = true;

        }

      }

    for(int i=0; i<mDimension; i++)

      for(int j=i+1; j<mDimension; j++)

        {

        tmp = 0.0f;

        for(int k=0; k<mDimension; k++)

          {

          tmp += baseV[i][k]*baseV[j][k];

          }

        cosA = ( (len[i]==0.0f || len[j]==0.0f) ? 0.0f : tmp/(float)Math.sqrt(len[i]*len[j]));

        if( cosA > 0.05f || cosA < -0.05f )

          {

          android.util.Log.e("dynamic", "cos angle between vectors "+i+" and "+j+" : "+cosA);

          error = true;

          }

        }

    if( error ) printBase("");

    }

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

  int getNext(int curr, float time)

    {

    switch(mMode)

      {

      case MODE_LOOP: return curr==numPoints-1 ? 0:curr+1;

      case MODE_PATH: return time<0.5f ? (curr+1) : (curr==0 ? 1 : curr-1);

      case MODE_JUMP: return curr==numPoints-1 ? 1:curr+1;

      default       : return 0;

      }

    }

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

  private void checkAngle(int index)

    {

    float cosA = 0.0f;

    for(int k=0;k<mDimension; k++)

      cosA += baseV[index][k]*old[k];

    if( cosA<0.0f )

      {

      for(int j=0; j<mDimension; j++)

        baseV[index][j] = -baseV[index][j];

      }

    }

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

// helper function in case we are interpolating through exactly 2 points

  protected void computeOrthonormalBase2(Static curr, Static next)

    {

    switch(mDimension)

      {

      case 1: Static1D curr1 = (Static1D)curr;

              Static1D next1 = (Static1D)next;

              baseV[0][0] = (next1.x-curr1.x);

              break;

      case 2: Static2D curr2 = (Static2D)curr;

              Static2D next2 = (Static2D)next;

              baseV[0][0] = (next2.x-curr2.x);

              baseV[0][1] = (next2.y-curr2.y);

              break;

      case 3: Static3D curr3 = (Static3D)curr;

              Static3D next3 = (Static3D)next;

              baseV[0][0] = (next3.x-curr3.x);

              baseV[0][1] = (next3.y-curr3.y);

              baseV[0][2] = (next3.z-curr3.z);

              break;

      case 4: Static4D curr4 = (Static4D)curr;

              Static4D next4 = (Static4D)next;

              baseV[0][0] = (next4.x-curr4.x);

              baseV[0][1] = (next4.y-curr4.y);

              baseV[0][2] = (next4.z-curr4.z);

              baseV[0][3] = (next4.w-curr4.w);

              break;

      case 5: Static5D curr5 = (Static5D)curr;

              Static5D next5 = (Static5D)next;

              baseV[0][0] = (next5.x-curr5.x);

              baseV[0][1] = (next5.y-curr5.y);

              baseV[0][2] = (next5.z-curr5.z);

              baseV[0][3] = (next5.w-curr5.w);

              baseV[0][4] = (next5.v-curr5.v);

              break;

      default: throw new RuntimeException("Unsupported dimension");

      }

    if( baseV[0][0] == 0.0f )

      {

      baseV[1][0] = 1.0f;

      baseV[1][1] = 0.0f;

      }

    else

      {

      baseV[1][0] = 0.0f;

      baseV[1][1] = 1.0f;

      }

    for(int i=2; i<mDimension; i++)

      {

      baseV[1][i] = 0.0f;

      }

    computeOrthonormalBase();

    }

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

// helper function in case we are interpolating through more than 2 points

  protected void computeOrthonormalBaseMore(float time,VectorCache vc)

    {

    for(int i=0; i<mDimension; i++)

      {

      baseV[0][i] = (3*vc.a[i]*time+2*vc.b[i])*time+vc.c[i];   // first derivative, i.e. velocity vector

      old[i]      = baseV[1][i];

      baseV[1][i] =  6*vc.a[i]*time+2*vc.b[i];                 // second derivative,i.e. acceleration vector

      }

    computeOrthonormalBase();

    }

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

// When this function gets called, baseV[0] and baseV[1] should have been filled with two mDimension-al

// vectors. This function then fills the rest of the baseV array with a mDimension-al Orthonormal base.

// (mDimension-2 vectors, pairwise orthogonal to each other and to the original 2). The function always

// leaves base[0] alone but generally speaking must adjust base[1] to make it orthogonal to base[0]!

// The whole baseV is then used to compute Noise.

//

// When computing noise of a point travelling along a N-dimensional path, there are three cases:

// a) we may be interpolating through 1 point, i.e. standing in place - nothing to do in this case

// b) we may be interpolating through 2 points, i.e. travelling along a straight line between them -

//    then pass the velocity vector in baseV[0] and anything linearly independent in base[1].

//    The output will then be discontinuous in dimensions>2 (sad corollary from the Hairy Ball Theorem)

//    but we don't care - we are travelling along a straight line, so velocity (aka baseV[0]!) does

//    not change.

// c) we may be interpolating through more than 2 points. Then interpolation formulas ensure the path

//    will never be a straight line, even locally -> we can pass in baseV[0] and baseV[1] the velocity

//    and the acceleration (first and second derivatives of the path) which are then guaranteed to be

//    linearly independent. Then we can ensure this is continuous in dimensions <=4. This leaves

//    dimension 5 (ATM WAVE is 5-dimensional) discontinuous -> WAVE will suffer from chaotic noise.

//

// Bear in mind here the 'normal' in 'orthonormal' means 'length equal to the length of the original

// velocity vector' (rather than the standard 1)

  protected void computeOrthonormalBase()

    {

    int last_non_zero=-1;

    float tmp;

    for(int i=0; i<mDimension; i++)

      if( baseV[0][i] != 0.0f )

        last_non_zero=i;

    if( last_non_zero==-1 )                                               ///

      {                                                                   //  velocity is the 0 vector -> two

      for(int i=0; i<mDimension-1; i++)                                   //  consecutive points we are interpolating

        for(int j=0; j<mDimension; j++)                                   //  through are identical -> no noise,

          baseV[i+1][j]= 0.0f;                                            //  set the base to 0 vectors.

      }                                                                   ///

    else

      {

      for(int i=1; i<mDimension; i++)                                     /// One iteration computes baseV[i][*]

        {                                                                 //  (aka b[i]), the i-th orthonormal vector.

        buf[i-1]=0.0f;                                                    //

                                                                          //  We can use (modified!) Gram-Schmidt.

        for(int k=0; k<mDimension; k++)                                   //

          {                                                               //

          if( i>=2 )                                                      //  b[0] = b[0]

            {                                                             //  b[1] = b[1] - (<b[1],b[0]>/<b[0],b[0]>)*b[0]

            old[k] = baseV[i][k];                                         //  b[2] = b[2] - (<b[2],b[0]>/<b[0],b[0]>)*b[0] - (<b[2],b[1]>/<b[1],b[1]>)*b[1]

            baseV[i][k]= (k==i-(last_non_zero>=i?1:0)) ? 1.0f : 0.0f;     //  b[3] = b[3] - (<b[3],b[0]>/<b[0],b[0]>)*b[0] - (<b[3],b[1]>/<b[1],b[1]>)*b[1] - (<b[3],b[2]>/<b[2],b[2]>)*b[2]

            }                                                             //  (...)

                                                                          //  then b[i] = b[i] / |b[i]|  ( Here really b[i] = b[i] / (|b[0]|/|b[i]|)

          tmp = baseV[i-1][k];                                            //

          buf[i-1] += tmp*tmp;                                            //

          }                                                               //

                                                                          //

        for(int j=0; j<i; j++)                                            //

          {                                                               //

          tmp = 0.0f;                                                     //

          for(int k=0;k<mDimension; k++) tmp += baseV[i][k]*baseV[j][k];  //

          tmp /= buf[j];                                                  //

          for(int k=0;k<mDimension; k++) baseV[i][k] -= tmp*baseV[j][k];  //

          }                                                               //

                                                                          //

        checkAngle(i);                                                    //

        }                                                                 /// end compute baseV[i][*]

      buf[mDimension-1]=0.0f;                                             /// Normalize

      for(int k=0; k<mDimension; k++)                                     //

        {                                                                 //

        tmp = baseV[mDimension-1][k];                                     //

        buf[mDimension-1] += tmp*tmp;                                     //

        }                                                                 //

                                                                          //

      for(int i=1; i<mDimension; i++)                                     //

        {                                                                 //

        tmp = (float)Math.sqrt(buf[0]/buf[i]);                            //

        for(int k=0;k<mDimension; k++) baseV[i][k] *= tmp;                //

        }                                                                 /// End Normalize

      }

    }

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

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

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

// 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 straight back to the first.

 * </ul>

 * 

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

 */

  public void setMode(int mode)

    {

    mMode = mode;  

    }

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

/**

 * Returns the number of Points this Dynamic has been fed with.

 *   

 * @return the number of Points we are currently interpolating through.

 */

  public synchronized int getNumPoints()

    {

    return numPoints;  

    }

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

/**

 * Sets how many revolutions we want to do.

 * <p>

 * Does not have to be an integer. What constitutes 'one revolution' depends on the MODE:

 * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}.

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

 * 

 * @param count the number of times we want to interpolate between our collection of Points.

 */

  public void setCount(float count)

    {

    mCount = count;  

    }

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

/**

 * Return the number of revolutions this Dynamic will make.

 * What constitutes 'one revolution' depends on the MODE:

 * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}.

 *

 * @return the number revolutions this Dynamic will make.

 */

  public float getCount()

    {

    return mCount;

    }

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

/**

 * Start running from the beginning again.

 *

 * If a Dynamic has been used already, and we want to use it again and start interpolating from the

 * first Point, first we need to reset it using this method.

 */

  public void resetToBeginning()

    {

    mStartTime = -1;

    }

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

/**

 * @param duration Number of milliseconds one revolution will take.

 *                 What constitutes 'one revolution' depends on the MODE:

 *                 {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}.

 */

  public void setDuration(long duration)

    {

    mDuration = duration;

    }

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

/**

 * @return Number of milliseconds one revolution will take.

 */

  public long getDuration()

    {

    return mDuration;

    }

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

/**

 * @param convexity If set to the default (1.0f) then interpolation between 4 points

 *                  (1,0) (0,1) (-1,0) (0,-1) will be the natural circle centered at (0,0) with radius 1.

 *                  The less it is, the less convex the circle becomes, ultimately when convexity=0.0f

 *                  then the interpolation shape will be straight lines connecting the four points.

 *                  Further setting this to negative values will make the shape concave.

 *                  Valid values: all floats. (although probably only something around (0,2) actually

 *                  makes sense)

 */

  public void setConvexity(float convexity)

    {

    if( mConvexity!=convexity )

      {

      mConvexity = convexity;

      cacheDirty = true;

      }

    }

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

/**

 * @return See {@link Dynamic#setConvexity(float)}

 */

  public float getConvexity()

    {

    return mConvexity;

    }

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

/**

 * Sets the access type this Dynamic will be working in.

 *

 * @param type {@link Dynamic#ACCESS_TYPE_RANDOM} or {@link Dynamic#ACCESS_TYPE_SEQUENTIAL}.

 */

  public void setAccessType(int type)

    {

    mAccessType = type;

    mLastPos = -1;

    }

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

/**

 * @return See {@link Dynamic#setSpeedMode(int)}

 */

  public float getSpeedMode()

    {

    return mSpeedMode;

    }

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

/**

 * Sets the way we compute the interpolation speed.

 *

 * @param mode {@link Dynamic#SPEED_MODE_SMOOTH} or {@link Dynamic#SPEED_MODE_SEGMENT_CONSTANT} or

 *             {@link Dynamic#SPEED_MODE_GLOBALLY_CONSTANT}

 */

  public void setSpeedMode(int mode)

    {

    if( mSpeedMode!=mode )

      {

      if( mSpeedMode==SPEED_MODE_SMOOTH )

        {

        for(int i=0; i<numPoints; i++)

          {

          tmpCache1 = vc.elementAt(i);

          smoothOutSegment(tmpCache1);

          }

        }

      mSpeedMode = mode;

      }

    }

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

/**

 * Return the Dimension, ie number of floats in a single Point this Dynamic interpolates through.

 *

 * @return number of floats in a single Point (ie its dimension) contained in the Dynamic.

 */

  public int getDimension()

    {

    return mDimension;

    }

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

/**

 * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.

 * <p>

 * This version differs from the previous in that it returns a boolean value which indicates whether

 * the interpolation is finished.

 *

 * @param buffer Float buffer we will write the results to.

 * @param offset Offset in the buffer where to write the result.

 * @param time   Time of interpolation. Time=0.0 is the beginning of the first revolution, time=1.0 - the end

 *               of the first revolution, time=2.5 - the middle of the third revolution.

 *               What constitutes 'one revolution' depends on the MODE:

 *               {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}.

 * @param step   Time difference between now and the last time we called this function. Needed to figure

 *               out if the previous time we were called the effect wasn't finished yet, but now it is.

 * @return true if the interpolation reached its end.

 */

  public boolean get(float[] buffer, int offset, long time, long step)

    {

    if( mDuration<=0.0f )

      {

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

      return false;

      }

    if( mStartTime==-1 )

      {

      mStartTime = time;

      mLastPos   = -1;

      }

    long diff = time-mPausedTime;

    if( mStartTime<mPausedTime && mCorrectedTime<mPausedTime && diff>=0 && diff<=step )

      {

      mCorrectedTime = mPausedTime;

      mStartTime += diff;

      step -= diff;

      }

    time -= mStartTime;

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

      {

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