commit 24d22f93f260cd5fece138a6d7e5576afc8bfe3c
Author: Leszek Koltunski <leszek@distoretedandroid.org>
Date:   Tue Nov 8 17:02:00 2016 +0000

    Progress with WindManager.

diff --git a/src/main/java/org/distorted/library/EffectQueue.java b/src/main/java/org/distorted/library/EffectQueue.java
index 4ee88b5..960978c 100644
--- a/src/main/java/org/distorted/library/EffectQueue.java
+++ b/src/main/java/org/distorted/library/EffectQueue.java
@@ -59,7 +59,7 @@ abstract class EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  public EffectQueue(DistortedObject obj, int numUniforms, int index)
+  EffectQueue(DistortedObject obj, int numUniforms, int index)
     {
     mNumEffects   = 0;
     mTotalEffects = 0;
@@ -92,6 +92,7 @@ abstract class EffectQueue
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+  @SuppressWarnings("unused")
   int getNumEffects()
     {
     return mNumEffects;  
@@ -294,7 +295,8 @@ abstract class EffectQueue
     
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // used only for debugging
-  
+
+  @SuppressWarnings("unused")
   protected String printEffects(int max)
     {
     long[] indexes = new long[mMax[mMaxIndex]];
diff --git a/src/main/java/org/distorted/library/type/Dynamic.java b/src/main/java/org/distorted/library/type/Dynamic.java
index 65b2dd4..858408f 100644
--- a/src/main/java/org/distorted/library/type/Dynamic.java
+++ b/src/main/java/org/distorted/library/type/Dynamic.java
@@ -77,7 +77,7 @@ public abstract class Dynamic
    * 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.
+   * Dynamic can only be used in one effect at a time.
    */
   public static final int ACCESS_SEQUENTIAL = 1;
 
@@ -155,8 +155,6 @@ public abstract class Dynamic
   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 int lastNon;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // hide this from Javadoc
   
@@ -248,6 +246,7 @@ public abstract class Dynamic
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // debugging only
 
+  @SuppressWarnings("unused")
   private void checkBase()
     {
     float tmp, cosA;
@@ -387,40 +386,6 @@ public abstract class Dynamic
     computeOrthonormalBase();
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// debugging
-/*
-  protected void computeOrthonormalBaseMoreDebug(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
-      baseV[1][i] =  6*vc.a[i]*time+2*vc.b[i];                 // second derivative,i.e. acceleration vector
-      }
-
-    float av=0.0f, vv=0.0f;
-
-    android.util.Log.e("dyn3D", " ==>  velocity     ("+baseV[0][0]+","+baseV[0][1]+","+baseV[0][2]+")");
-    android.util.Log.e("dyn3D", " ==>  acceleration ("+baseV[1][0]+","+baseV[1][1]+","+baseV[1][2]+")");
-
-    for(int k=0; k<mDimension; k++)
-      {
-      vv += baseV[0][k]*baseV[0][k];
-      av += baseV[1][k]*baseV[0][k];
-      }
-
-    android.util.Log.e("dyn3D", " ==>  av: "+av+" vv="+vv);
-
-    av /= vv;
-
-    for(int k=0;k<mDimension; k++)
-      {
-      baseV[1][k] -= av*baseV[0][k];
-      }
-
-    android.util.Log.e("dyn3D", " ==>  second base ("+baseV[1][0]+","+baseV[1][1]+","+baseV[1][2]+")");
-    }
-*/
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // helper function in case we are interpolating through more than 2 points
 
@@ -467,10 +432,6 @@ public abstract class Dynamic
     for(int i=0; i<mDimension; i++)
       if( baseV[0][i] != 0.0f )
         last_non_zero=i;
-/*
-if( last_non_zero != lastNon )
-  android.util.Log.e("dynamic", "lastNon="+lastNon+" last_non_zero="+last_non_zero);
-*/
 
     if( last_non_zero==-1 )                                               ///
       {                                                                   //  velocity is the 0 vector -> two
@@ -521,18 +482,16 @@ if( last_non_zero != lastNon )
         }                                                                 /// End Normalize
       }
 
-//lastNon = last_non_zero;
-
     //printBase("end");
     //checkBase();
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // internal debugging only!
-  
+
   public String print()
     {
-    return "duration="+mDuration+" count="+mCount+" Noise="+mNoise+" numVectors="+numPoints+" mMode="+mMode;
+    return "duration="+mDuration+" count="+mCount+" Noise[0]="+mNoise[0]+" numVectors="+numPoints+" mMode="+mMode;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -554,7 +513,6 @@ if( last_non_zero != lastNon )
  * 
  * @param mode {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}.
  */
-
   public void setMode(int mode)
     {
     mMode = mode;  
@@ -594,7 +552,6 @@ if( last_non_zero != lastNon )
  * @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;
@@ -605,9 +562,7 @@ if( last_non_zero != lastNon )
 /**
  * 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}.
+ * @param mode {@link Dynamic#ACCESS_RANDOM} or {@link Dynamic#ACCESS_SEQUENTIAL}.
  */
   public void setAccessMode(int mode)
     {
@@ -619,12 +574,11 @@ if( last_non_zero != lastNon )
 /**
  * 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 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 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 )
@@ -649,7 +603,7 @@ if( last_non_zero != lastNon )
  * 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 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 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.