commit d403b46692bfa9775f62a3be8e7935dbca5d6183
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Tue Jun 1 13:38:43 2021 +0200

    Dynamics: consolidation of code.

diff --git a/src/main/java/org/distorted/library/type/Dynamic.java b/src/main/java/org/distorted/library/type/Dynamic.java
index 0cf4977..119e255 100644
--- a/src/main/java/org/distorted/library/type/Dynamic.java
+++ b/src/main/java/org/distorted/library/type/Dynamic.java
@@ -69,7 +69,7 @@ public abstract class Dynamic
    * 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;
+  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.
@@ -109,6 +109,8 @@ public abstract class Dynamic
   protected double mLastPos;
   protected int mAccessType;
   protected int mSpeedMode;
+  protected float mTmpTime;
+  protected int mTmpVec, mTmpSeg;
 
   protected class VectorNoise
     {
@@ -234,6 +236,38 @@ public abstract class Dynamic
     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)
diff --git a/src/main/java/org/distorted/library/type/Dynamic1D.java b/src/main/java/org/distorted/library/type/Dynamic1D.java
index 1e2e2e1..1538907 100644
--- a/src/main/java/org/distorted/library/type/Dynamic1D.java
+++ b/src/main/java/org/distorted/library/type/Dynamic1D.java
@@ -407,58 +407,30 @@ public class Dynamic1D extends Dynamic implements Data1D
              
               buffer[offset] = (next.x-curr.x)*time + curr.x;
               break;
-      default:float t = time;
-              int vecCurr, segment;
+      default:computeSegmentAndTime(time);
 
-              switch(mMode)
-                {
-                case MODE_LOOP: time = time*numPoints;
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                case MODE_PATH: segment = (int)(2*t*(numPoints-1));
-
-                                if( t<=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!
-                                  time = 2*t*(numPoints-1);
-                                  vecCurr = segment;
-                                  }
-                                else
-                                  {
-                                  time = 2*(1-t)*(numPoints-1);
-                                  vecCurr = 2*numPoints-3-segment;
-                                  }
-                                break;
-                case MODE_JUMP: time = time*(numPoints-1);
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                default       : vecCurr = 0;
-                                segment = 0;
-                }
-
-              if( vecCurr>=0 && vecCurr<numPoints )
+              if( mTmpVec>=0 && mTmpVec<numPoints )
                 {
                 if( cacheDirty ) recomputeCache();  // recompute cache if we have added or remove vectors since last computation
-                else if( mSegment!= segment )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
+                else if( mSegment!= mTmpSeg )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
                   {
-                  int vecNext = getNext(vecCurr,t);
+                  int vecNext = getNext(mTmpVec,time);
                   next = vv.elementAt(vecNext);
                   tmpCache2 = vc.elementAt(vecNext);
-              
+
                   if( tmpCache2.cached[0]!=next.x ) recomputeCache();
                   }
 
-                if( mSegment!= segment && vn!=null ) vn.elementAt(vecCurr).computeNoise();
+                if( mSegment!= mTmpSeg && vn!=null ) vn.elementAt(mTmpVec).computeNoise();
 
-                mSegment = segment;
-                time = time-vecCurr;
-                tmpCache1 = vc.elementAt(vecCurr);
+                mSegment = mTmpSeg;
+                time = mTmpTime-mTmpVec;
+                tmpCache1 = vc.elementAt(mTmpVec);
                 if( mSpeedMode==SPEED_MODE_SEGMENT_CONSTANT ) time = smoothSpeed(time, tmpCache1);
 
                 if( vn!=null )
                   {
-                  time = noise(time,vecCurr);
+                  time = noise(time,mTmpVec);
                   }
             
                 buffer[offset] = ((tmpCache1.a[0]*time+ tmpCache1.b[0])*time+ tmpCache1.c[0])*time+ tmpCache1.d[0];
diff --git a/src/main/java/org/distorted/library/type/Dynamic2D.java b/src/main/java/org/distorted/library/type/Dynamic2D.java
index 6c97d79..3ed482e 100644
--- a/src/main/java/org/distorted/library/type/Dynamic2D.java
+++ b/src/main/java/org/distorted/library/type/Dynamic2D.java
@@ -440,61 +440,33 @@ public class Dynamic2D extends Dynamic implements Data2D
                 }
               
               break;
-      default:float t = time;
-              int vecCurr, segment;
+      default:computeSegmentAndTime(time);
 
-              switch(mMode)
-                {
-                case MODE_LOOP: time = time*numPoints;
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                case MODE_PATH: segment = (int)(2*t*(numPoints-1));
-
-                                if( t<=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!
-                                  time = 2*t*(numPoints-1);
-                                  vecCurr = segment;
-                                  }
-                                else
-                                  {
-                                  time = 2*(1-t)*(numPoints-1);
-                                  vecCurr = 2*numPoints-3-segment;
-                                  }
-                                break;
-                case MODE_JUMP: time = time*(numPoints-1);
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                default       : vecCurr = 0;
-                                segment = 0;
-                }
-
-              if( vecCurr>=0 && vecCurr<numPoints )
+              if( mTmpVec>=0 && mTmpVec<numPoints )
                 {
                 if( cacheDirty ) recomputeCache();  // recompute cache if we have added or remove vectors since last computation
-                else if( mSegment!= segment )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
+                else if( mSegment!= mTmpSeg )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
                   {
-                  int vecNext = getNext(vecCurr,t);
+                  int vecNext = getNext(mTmpVec,time);
                   next = vv.elementAt(vecNext);
                   tmpCache2 = vc.elementAt(vecNext);
 
                   if( tmpCache2.cached[0]!=next.x || tmpCache2.cached[1]!=next.y ) recomputeCache();
                   }
 
-                if( mSegment!= segment && vn!=null ) vn.elementAt(vecCurr).computeNoise();
+                if( mSegment!= mTmpSeg && vn!=null ) vn.elementAt(mTmpVec).computeNoise();
 
-                mSegment = segment;
-                time = time-vecCurr;
-                tmpCache1 = vc.elementAt(vecCurr);
+                mSegment = mTmpSeg;
+                time = mTmpTime-mTmpVec;
+                tmpCache1 = vc.elementAt(mTmpVec);
                 if( mSpeedMode==SPEED_MODE_SEGMENT_CONSTANT ) time = smoothSpeed(time, tmpCache1);
 
                 if( vn!=null )
                   {
-                  time = noise(time,vecCurr);
+                  time = noise(time,mTmpVec);
 
-                  baseV[1][0] = (3* tmpCache1.a[0]*time+2* tmpCache1.b[0])*time + tmpCache1.c[0];
-                  baseV[1][1] = (3* tmpCache1.a[1]*time+2* tmpCache1.b[1])*time + tmpCache1.c[1];
+                  baseV[1][0] = (3*tmpCache1.a[0]*time + 2*tmpCache1.b[0])*time + tmpCache1.c[0];
+                  baseV[1][1] = (3*tmpCache1.a[1]*time + 2*tmpCache1.b[1])*time + tmpCache1.c[1];
                  
                   buffer[offset  ]= ((tmpCache1.a[0]*time+ tmpCache1.b[0])*time+ tmpCache1.c[0])*time+ tmpCache1.d[0] +baseV[1][1]*mFactor[0];
                   buffer[offset+1]= ((tmpCache1.a[1]*time+ tmpCache1.b[1])*time+ tmpCache1.c[1])*time+ tmpCache1.d[1] -baseV[1][0]*mFactor[0];
diff --git a/src/main/java/org/distorted/library/type/Dynamic3D.java b/src/main/java/org/distorted/library/type/Dynamic3D.java
index 4322d4f..e329dc8 100644
--- a/src/main/java/org/distorted/library/type/Dynamic3D.java
+++ b/src/main/java/org/distorted/library/type/Dynamic3D.java
@@ -464,58 +464,30 @@ public class Dynamic3D extends Dynamic implements Data3D
                 }
              
               break;
-      default:float t = time;
-              int vecCurr, segment;
+      default:computeSegmentAndTime(time);
 
-              switch(mMode)
-                {
-                case MODE_LOOP: time = time*numPoints;
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                case MODE_PATH: segment = (int)(2*t*(numPoints-1));
-
-                                if( t<=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!
-                                  time = 2*t*(numPoints-1);
-                                  vecCurr = segment;
-                                  }
-                                else
-                                  {
-                                  time = 2*(1-t)*(numPoints-1);
-                                  vecCurr = 2*numPoints-3-segment;
-                                  }
-                                break;
-                case MODE_JUMP: time = time*(numPoints-1);
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                default       : vecCurr = 0;
-                                segment = 0;
-                }
-
-              if( vecCurr>=0 && vecCurr<numPoints )
+              if( mTmpVec>=0 && mTmpVec<numPoints )
                 {
                 if( cacheDirty ) recomputeCache();  // recompute cache if we have added or remove vectors since last computation
-                else if( mSegment!= segment )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
+                else if( mSegment!= mTmpSeg )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
                   {
-                  int vecNext = getNext(vecCurr,t);
+                  int vecNext = getNext(mTmpVec,time);
                   next = vv.elementAt(vecNext);
                   tmpCache2 = vc.elementAt(vecNext);
 
                   if( tmpCache2.cached[0]!=next.x || tmpCache2.cached[1]!=next.y || tmpCache2.cached[2]!=next.z ) recomputeCache();
                   }
 
-                if( mSegment!= segment && vn!=null ) vn.elementAt(vecCurr).computeNoise();
+                if( mSegment!= mTmpSeg && vn!=null ) vn.elementAt(mTmpVec).computeNoise();
 
-                mSegment = segment;
-                time = time-vecCurr;
-                tmpCache1 = vc.elementAt(vecCurr);
+                mSegment = mTmpSeg;
+                time = mTmpTime-mTmpVec;
+                tmpCache1 = vc.elementAt(mTmpVec);
                 if( mSpeedMode==SPEED_MODE_SEGMENT_CONSTANT ) time = smoothSpeed(time, tmpCache1);
 
                 if( vn!=null )
                   {
-                  time = noise(time,vecCurr);
+                  time = noise(time,mTmpVec);
               
                   computeOrthonormalBaseMore(time, tmpCache1);
                  
diff --git a/src/main/java/org/distorted/library/type/Dynamic4D.java b/src/main/java/org/distorted/library/type/Dynamic4D.java
index 53f448c..e639a35 100644
--- a/src/main/java/org/distorted/library/type/Dynamic4D.java
+++ b/src/main/java/org/distorted/library/type/Dynamic4D.java
@@ -487,58 +487,30 @@ public class Dynamic4D extends Dynamic implements Data4D
                 }
                 
               break;
-      default:float t = time;
-              int vecCurr, segment;
+      default:computeSegmentAndTime(time);
 
-              switch(mMode)
-                {
-                case MODE_LOOP: time = time*numPoints;
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                case MODE_PATH: segment = (int)(2*t*(numPoints-1));
-
-                                if( t<=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!
-                                  time = 2*t*(numPoints-1);
-                                  vecCurr = segment;
-                                  }
-                                else
-                                  {
-                                  time = 2*(1-t)*(numPoints-1);
-                                  vecCurr = 2*numPoints-3-segment;
-                                  }
-                                break;
-                case MODE_JUMP: time = time*(numPoints-1);
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                default       : vecCurr = 0;
-                                segment = 0;
-                }
-
-              if( vecCurr>=0 && vecCurr<numPoints )
+              if( mTmpVec>=0 && mTmpVec<numPoints )
                 {
                 if( cacheDirty ) recomputeCache();  // recompute cache if we have added or remove vectors since last computation
-                else if( mSegment!= segment )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
+                else if( mSegment!= mTmpSeg )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
                   {
-                  int vecNext = getNext(vecCurr,t);
+                  int vecNext = getNext(mTmpVec,time);
                   next = vv.elementAt(vecNext);
                   tmpCache2 = vc.elementAt(vecNext);
 
                   if( tmpCache2.cached[0]!=next.x || tmpCache2.cached[1]!=next.y || tmpCache2.cached[2]!=next.z || tmpCache2.cached[3]!=next.w ) recomputeCache();
                   }
 
-                if( mSegment!= segment && vn!=null ) vn.elementAt(vecCurr).computeNoise();
+                if( mSegment!= mTmpSeg && vn!=null ) vn.elementAt(mTmpVec).computeNoise();
 
-                mSegment = segment;
-                time = time-vecCurr;
-                tmpCache1 = vc.elementAt(vecCurr);
+                mSegment = mTmpSeg;
+                time = mTmpTime-mTmpVec;
+                tmpCache1 = vc.elementAt(mTmpVec);
                 if( mSpeedMode==SPEED_MODE_SEGMENT_CONSTANT ) time = smoothSpeed(time, tmpCache1);
 
                 if( vn!=null )
                   {
-                  time = noise(time,vecCurr);
+                  time = noise(time,mTmpVec);
               
                   computeOrthonormalBaseMore(time, tmpCache1);
 
diff --git a/src/main/java/org/distorted/library/type/Dynamic5D.java b/src/main/java/org/distorted/library/type/Dynamic5D.java
index 373505e..b32eb95 100644
--- a/src/main/java/org/distorted/library/type/Dynamic5D.java
+++ b/src/main/java/org/distorted/library/type/Dynamic5D.java
@@ -510,58 +510,30 @@ public class Dynamic5D extends Dynamic implements Data5D
                 }
                 
               break;
-      default:float t = time;
-              int vecCurr, segment;
+      default:computeSegmentAndTime(time);
 
-              switch(mMode)
-                {
-                case MODE_LOOP: time = time*numPoints;
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                case MODE_PATH: segment = (int)(2*t*(numPoints-1));
-
-                                if( t<=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!
-                                  time = 2*t*(numPoints-1);
-                                  vecCurr = segment;
-                                  }
-                                else
-                                  {
-                                  time = 2*(1-t)*(numPoints-1);
-                                  vecCurr = 2*numPoints-3-segment;
-                                  }
-                                break;
-                case MODE_JUMP: time = time*(numPoints-1);
-                                segment = (int)time;
-                                vecCurr = segment;
-                                break;
-                default       : vecCurr = 0;
-                                segment = 0;
-                }
-
-              if( vecCurr>=0 && vecCurr<numPoints )
+              if( mTmpVec>=0 && mTmpVec<numPoints )
                 {
                 if( cacheDirty ) recomputeCache();  // recompute cache if we have added or remove vectors since last computation
-                else if( mSegment!= segment )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
+                else if( mSegment!= mTmpSeg )       // ...or if we have just passed a vector and the vector we are currently flying to has changed
                   {
-                  int vecNext= getNext(vecCurr,t);
+                  int vecNext = getNext(mTmpVec,time);
                   next = vv.elementAt(vecNext);
                   tmpCache2 = vc.elementAt(vecNext);
 
                   if( tmpCache2.cached[0]!=next.x || tmpCache2.cached[1]!=next.y || tmpCache2.cached[2]!=next.z || tmpCache2.cached[3]!=next.w || tmpCache2.cached[4]!=next.v ) recomputeCache();
                   }
 
-                if( mSegment!= segment && vn!=null ) vn.elementAt(vecCurr).computeNoise();
+                if( mSegment!= mTmpSeg && vn!=null ) vn.elementAt(mTmpVec).computeNoise();
 
-                mSegment = segment;
-                time = time-vecCurr;
-                tmpCache1 = vc.elementAt(vecCurr);
+                mSegment = mTmpSeg;
+                time = mTmpTime-mTmpVec;
+                tmpCache1 = vc.elementAt(mTmpVec);
                 if( mSpeedMode==SPEED_MODE_SEGMENT_CONSTANT ) time = smoothSpeed(time, tmpCache1);
 
                 if( vn!=null )
                   {
-                  time = noise(time,vecCurr);
+                  time = noise(time,mTmpVec);
               
                   computeOrthonormalBaseMore(time, tmpCache1);