/src/main/java/org/distorted/library/type/Dynamic.java - Diff - Distorted Android

« Previous | Next »

Revision 9aabc9eb

Added by Leszek Koltunski almost 3 years ago

ID 9aabc9eb2384ddb390f585b756faff9ce3188e8f
Parent bf444dc6
Child d403b466

Dynamics: introduce two speed modes - smooth and segment_constant.
Prepare the third mode - globally_constant.

     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;
       /**
        * One revolution takes us from the first point to the last and back to first through the shortest path.
        */
-...
       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 class VectorNoise
+        {
-...
       protected float[][] baseV;
       ///////////////////////////////////////////////////////////////////////////////////////////////////
       // the coefficients of the X(t), Y(t) and Z(t) polynomials: X(t) = ax*T^3 + bx*T^2 + cx*t + dx  etc.
       // (tangent) is the vector tangent to the path.
       // 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
-...
         float[] b;
         float[] c;
         float[] d;
         float[] tangent;
         float[] velocity;
         float[] cached;
         float[] path_ratio;
         VectorCache()
+          {
-...
           b = new float[mDimension];
           c = new float[mDimension];
           d = new float[mDimension];
           tangent = new float[mDimension];
           cached = new float[mDimension];
           velocity   = new float[mDimension];
           cached     = new float[mDimension];
           path_ratio = new float[NUM_RATIO];
+          }
+        }
       protected Vector<VectorCache> vc;
       protected VectorCache tmp1, tmp2;
       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();
-...
         mSegment   = -1;
         mLastPos   = -1;
         mAccessType= ACCESS_TYPE_RANDOM;
         mSpeedMode = SPEED_MODE_SMOOTH;
         mConvexity = 1.0f;
         mStartTime = -1;
         mCorrectedTime = 0;
-...
         mPausedTime = System.currentTimeMillis();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       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)
-...
         if( cosA<0.0f )
+          {
     /*
           /// DEBUGGING ////
           String s = index+" (";
           float t;
           for(int j=0; j<mDimension; j++)
+            {
             t = ((int)(100*baseV[index][j]))/(100.0f);
             s+=(" "+t);
+            }
           s += ") (";
           for(int j=0; j<mDimension; j++)
+            {
             t = ((int)(100*old[j]))/(100.0f);
             s+=(" "+t);
+            }
           s+= ")";
           android.util.Log.e("dynamic", "kat: " + s);
           /// END DEBUGGING ///
     */
           for(int j=0; j<mDimension; j++)
             baseV[index][j] = -baseV[index][j];
+          }
-...
         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.

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 9aabc9eb

Added by Leszek Koltunski almost 3 years ago