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

« Previous | Next »

Revision bdb341bc

Added by Leszek Koltunski over 7 years ago

ID bdb341bc3c57906d9f971ba34e715a9a7fb2e784
Parent 65d5505f
Child 24d22f93

Dynamics: Introduce 2 Modes of operation:

- 'random access' mode, where we are able to call a single Dynamic from multiple thread simultaneously.
- 'sequential' mode, which only permits sequential interpolation from one client.

The second mode has an advantage when one needs to change mDuration: it keeps on interpolating smoothly. In the first mode, this is not possible.

        */
       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_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
        * one Dynamic can only be used in one effect at a time.
        */
       public static final int ACCESS_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 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 mAccessMode;
       protected class VectorNoise
+        {
-...
         mCount     = count;
         mDimension = dimension;
         mSegment   = -1;
         mLastPos   = -1;
         mAccessMode= ACCESS_RANDOM;
         baseV      = new float[mDimension][mDimension];
         buf        = new float[mDimension];
         old        = new float[mDimension];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void interpolateMain(float[] buffer, int offset, long currentDuration)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
+          }
         else
+          {
           double x = (double)currentDuration/mDuration;
           if( x<=mCount || mCount<=0.0f )
+            {
             interpolate(buffer,offset, (float)(x-(int)x) );
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean interpolateMain(float[] buffer, int offset, long currentDuration, long step)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
           return false;
+          }
         double x = (double)currentDuration/mDuration;
         if( x<=mCount || mCount<=0.0f )
+          {
           interpolate(buffer,offset, (float)(x-(int)x) );
           if( currentDuration+step > mDuration*mCount && mCount>0.0f )
+            {
             interpolate(buffer,offset,mCount-(int)mCount);
             return true;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected float noise(float time,int vecNum)
-...
         mDuration = duration;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the access mode this Dynamic will be working in.
+     *
      * @param mode ACCESS_RANDOM or ACCESS_SEQUENTIAL.
      *             see {@link Dynamic#ACCESS_RANDOM}.
      *             see {@link Dynamic#ACCESS_SEQUENTIAL}.
      */
       public void setAccessMode(int mode)
+        {
         mAccessMode = mode;
         mLastPos = -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
+     *
      * @param buffer Float buffer we will write the resulting Static1D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      */
       public void interpolateMain(float[] buffer, int offset, long time)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
+          }
         else
+          {
           double pos = (double)time/mDuration;
           if( pos<=mCount || mCount<=0.0f )
+            {
             interpolate(buffer,offset, (float)(pos-(int)pos) );
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 resulting Static1D to.
      * @param offset Offset in the buffer where to write the result.
      * @param time Time of interpolation. Time=0.0 would return the first Point, Time=0.5 - the last,
      *             time=1.0 - the first again, and time 0.1 would be 1/5 of the way between the first and the last Points.
      * @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 interpolateMain(float[] buffer, int offset, long time, long step)
+        {
         if( mDuration<=0.0f )
+          {
           interpolate(buffer,offset,mCount-(int)mCount);
           return false;
+          }
         double pos;
         if( mAccessMode==ACCESS_SEQUENTIAL )
+          {
           pos = mLastPos<0 ? (double)time/mDuration : (double)step/mDuration + mLastPos;
           mLastPos = pos;
+          }
         else
+          {
           pos = (double)time/mDuration;
+          }
         if( pos<=mCount || mCount<=0.0f )
+          {
           interpolate(buffer,offset, (float)(pos-(int)pos) );
           if( time+step > mDuration*mCount && mCount>0.0f )
+            {
             interpolate(buffer,offset,mCount-(int)mCount);
             return true;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // end of DistortedInterpolator
+      }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision bdb341bc

Added by Leszek Koltunski over 7 years ago