commit 15aa7d946f2afb924f4a2465aa79f00e95c428e1
Author: Leszek Koltunski <leszek@distoretedandroid.org>
Date:   Thu Jun 8 14:53:05 2017 +0100

    Progress with support for Effect classes.

diff --git a/src/main/java/org/distorted/library/effect/Effect.java b/src/main/java/org/distorted/library/effect/Effect.java
index 080ae83..4a90d18 100644
--- a/src/main/java/org/distorted/library/effect/Effect.java
+++ b/src/main/java/org/distorted/library/effect/Effect.java
@@ -40,6 +40,10 @@ public abstract class Effect
   public static final int LENGTH = 4;           // The number of effect types above.
   public static final int MASK= (1<<LENGTH)-1;  // Needed when we do bitwise operations on Effect Types.
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public abstract boolean compute(float[] uniforms, int index, long currentDuration, long step );
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public static void onDestroy()
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffect.java b/src/main/java/org/distorted/library/effect/FragmentEffect.java
index fbd4784..9f63d06 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffect.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffect.java
@@ -29,6 +29,8 @@ import org.distorted.library.type.Static;
 
 public abstract class FragmentEffect extends Effect
   {
+  public static final int NUM_UNIFORMS = 8;
+
   public static final int CHROMA            = 0;
   public static final int SMOOTH_CHROMA     = 1;
   public static final int ALPHA             = 2;
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
index 8146dd8..dd5dc4e 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
@@ -66,4 +66,19 @@ public class FragmentEffectAlpha extends FragmentEffect
       mStatic0 = (Static1D)alpha;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
index 1c9ceca..0968057 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
@@ -66,4 +66,19 @@ public class FragmentEffectBrightness extends FragmentEffect
       mStatic0 = (Static1D)brightness;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
index 511e197..33c6bf8 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
@@ -87,4 +87,30 @@ public class FragmentEffectChroma extends FragmentEffect
       mStatic1 = (Static3D)color;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic1!=null )
+      {
+      mDynamic1.interpolateMain(uniforms,index+1,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+1] = ((Static3D)mStatic1).getX();
+      uniforms[index+2] = ((Static3D)mStatic1).getY();
+      uniforms[index+3] = ((Static3D)mStatic1).getZ();
+      }
+
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
index 5b0cc1b..ea88713 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
@@ -66,4 +66,19 @@ public class FragmentEffectContrast extends FragmentEffect
       mStatic0 = (Static1D)contrast;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
index 2523c0b..2af5c70 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
@@ -66,4 +66,19 @@ public class FragmentEffectSaturation extends FragmentEffect
       mStatic0 = (Static1D)saturation;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffect.java b/src/main/java/org/distorted/library/effect/MatrixEffect.java
index a931012..9fa6f30 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffect.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffect.java
@@ -27,6 +27,8 @@ import org.distorted.library.type.*;
 
 public abstract class MatrixEffect extends Effect
   {
+  public static final int NUM_UNIFORMS = 7;
+
   public static final int MOVE       = 0;
   public static final int SCALE      = 1;
   public static final int ROTATE     = 2;
@@ -39,7 +41,8 @@ public abstract class MatrixEffect extends Effect
 
   Dynamic mDynamic0,mDynamic1;
   Static  mStatic0 , mStatic1;
-  Data3D mCenter;
+  Dynamic3D mDynamicCenter;
+  Static3D mStaticCenter;
 
   private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
   private final static int[]   mUnityDim = new int[NUM_EFFECTS];
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectMove.java b/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
index 3d20915..79bbe37 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
@@ -47,4 +47,22 @@ public class MatrixEffectMove extends MatrixEffect
       mDynamic0 = (Dynamic3D)vector;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static3D)mStatic0).getX();
+      uniforms[index+1] = ((Static3D)mStatic0).getY();
+      uniforms[index+2] = ((Static3D)mStatic0).getZ();
+
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java b/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
index c4c3d51..ae2f863 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
@@ -21,7 +21,9 @@ package org.distorted.library.effect;
 
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
+import org.distorted.library.type.Dynamic3D;
 import org.distorted.library.type.Dynamic4D;
+import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -48,6 +50,43 @@ public class MatrixEffectQuaternion extends MatrixEffect
       mDynamic0 = (Dynamic4D)quaternion;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D)
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+4,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+4] = mStaticCenter.getX();
+      uniforms[index+5] = mStaticCenter.getY();
+      uniforms[index+6] = mStaticCenter.getZ();
+      }
+
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static4D)mStatic0).getX();
+      uniforms[index+1] = ((Static4D)mStatic0).getY();
+      uniforms[index+2] = ((Static4D)mStatic0).getZ();
+      uniforms[index+3] = ((Static4D)mStatic0).getW();
+
+      return false;
+      }
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java b/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
index 42d8fa5..cf55c18 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
@@ -23,6 +23,7 @@ import org.distorted.library.type.Data1D;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic1D;
+import org.distorted.library.type.Dynamic3D;
 import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static1D;
 import org.distorted.library.type.Static3D;
@@ -53,7 +54,15 @@ public class MatrixEffectRotate extends MatrixEffect
       }
 
     mStatic1 = axis;
-    mCenter = center;
+
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -71,7 +80,53 @@ public class MatrixEffectRotate extends MatrixEffect
       mDynamic0 = (Dynamic4D)angleaxis;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+4,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+4] = mStaticCenter.getX();
+      uniforms[index+5] = mStaticCenter.getY();
+      uniforms[index+6] = mStaticCenter.getZ();
+      }
+
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      if( mStatic1 != null )
+        {
+        uniforms[index  ] = ((Static1D)mStatic0).getX();
+        uniforms[index+1] = ((Static3D)mStatic1).getX();
+        uniforms[index+2] = ((Static3D)mStatic1).getY();
+        uniforms[index+3] = ((Static3D)mStatic1).getZ();
+        }
+      else
+        {
+        uniforms[index  ] = ((Static4D)mStatic0).getX();
+        uniforms[index+1] = ((Static4D)mStatic0).getY();
+        uniforms[index+2] = ((Static4D)mStatic0).getZ();
+        uniforms[index+3] = ((Static4D)mStatic0).getW();
+        }
+
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectScale.java b/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
index 4a2d1d2..20e57f0 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
@@ -56,4 +56,22 @@ public class MatrixEffectScale extends MatrixEffect
 
     mStatic0 = new Static3D(scale,scale,scale);
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static3D)mStatic0).getX();
+      uniforms[index+1] = ((Static3D)mStatic0).getY();
+      uniforms[index+2] = ((Static3D)mStatic0).getZ();
+
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectShear.java b/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
index c3f61ff..cbdec55 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
@@ -47,6 +47,42 @@ public class MatrixEffectShear extends MatrixEffect
       mDynamic0 = (Dynamic3D)shear;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+4,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+4] = mStaticCenter.getX();
+      uniforms[index+5] = mStaticCenter.getY();
+      uniforms[index+6] = mStaticCenter.getZ();
+      }
+
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static3D)mStatic0).getX();
+      uniforms[index+1] = ((Static3D)mStatic0).getY();
+      uniforms[index+2] = ((Static3D)mStatic0).getZ();
+
+      return false;
+      }
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffect.java b/src/main/java/org/distorted/library/effect/PostprocessEffect.java
index 707da85..a3c736e 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffect.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffect.java
@@ -28,6 +28,8 @@ import org.distorted.library.type.Static;
 
 public abstract class PostprocessEffect extends Effect
   {
+  public static final int NUM_UNIFORMS = 5;
+
   public static final int BLUR       =0;
   public static final int GLOW       =1;
   public static final int NUM_EFFECTS=2;
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
index b875620..d4f968b 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
@@ -47,4 +47,19 @@ public class PostprocessEffectBlur extends PostprocessEffect
       mStatic0  = (Static1D)radius;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
index 8bd9f28..ae0c06e 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
@@ -59,4 +59,31 @@ public class PostprocessEffectGlow extends PostprocessEffect
       mStatic1  = (Static4D)color;
       }
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    if( mDynamic1!=null )
+      {
+      mDynamic1.interpolateMain(uniforms,index+1,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+1] = ((Static4D)mStatic1).getX();
+      uniforms[index+2] = ((Static4D)mStatic1).getY();
+      uniforms[index+3] = ((Static4D)mStatic1).getZ();
+      uniforms[index+4] = ((Static4D)mStatic1).getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      return mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static1D)mStatic0).getX();
+      return false;
+      }
+    }
   }
diff --git a/src/main/java/org/distorted/library/effect/VertexEffect.java b/src/main/java/org/distorted/library/effect/VertexEffect.java
index 00a2a8e..641317c 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffect.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffect.java
@@ -19,10 +19,12 @@
 
 package org.distorted.library.effect;
 
-import org.distorted.library.type.Data3D;
-import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic;
+import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // VERTEX EFFECTS
@@ -30,6 +32,8 @@ import org.distorted.library.type.Static;
 
 public abstract class VertexEffect extends Effect
   {
+  public static final int NUM_UNIFORMS = 12;
+
   public static final int DISTORT    =0;
   public static final int DEFORM     =1;
   public static final int SINK       =2;
@@ -43,8 +47,10 @@ public abstract class VertexEffect extends Effect
 
   Dynamic mDynamic0;
   Static mStatic0;
-  Data3D mCenter;
-  Data4D mRegion;
+  Dynamic3D mDynamicCenter;
+  Static3D  mStaticCenter;
+  Dynamic4D mDynamicRegion;
+  Static4D  mStaticRegion;
 
   private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
   private final static int[]   mUnityDim = new int[NUM_EFFECTS];
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDeform.java b/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
index 50bab5e..5cbaae6 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
@@ -22,7 +22,9 @@ package org.distorted.library.effect;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -48,8 +50,23 @@ public class VertexEffectDeform extends VertexEffect
       mStatic0 = (Static3D)vector;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -67,6 +84,58 @@ public class VertexEffectDeform extends VertexEffect
       mStatic0 = (Static3D)vector;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret = false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
+      {
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static3D)mStatic0).getX();
+      uniforms[index+1] = ((Static3D)mStatic0).getY();
+      uniforms[index+2] = ((Static3D)mStatic0).getZ();
+      }
+
+    return ret;
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDistort.java b/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
index 75c6cbc..fb1a43d 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
@@ -22,7 +22,9 @@ package org.distorted.library.effect;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -48,8 +50,23 @@ public class VertexEffectDistort extends VertexEffect
       mStatic0 = (Static3D)vector;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -67,6 +84,62 @@ public class VertexEffectDistort extends VertexEffect
       mStatic0 = (Static3D)vector;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret = false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
+      {
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static3D)mStatic0).getX();
+      uniforms[index+1] = ((Static3D)mStatic0).getY();
+      uniforms[index+2] = ((Static3D)mStatic0).getZ();
+      }
+
+    uniforms[index+1] =-uniforms[index+1];
+
+    return ret;
     }
   }
+
+
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectPinch.java b/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
index 130bcab..4015581 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
@@ -19,11 +19,15 @@
 
 package org.distorted.library.effect;
 
-import org.distorted.library.type.Data1D;
+import org.distorted.library.type.Data2D;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
-import org.distorted.library.type.Dynamic1D;
-import org.distorted.library.type.Static1D;
+import org.distorted.library.type.Dynamic2D;
+import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
+import org.distorted.library.type.Static2D;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -36,38 +40,106 @@ public class VertexEffectPinch extends VertexEffect
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public VertexEffectPinch(Data1D pinch, Data3D center, Data4D region)
+  public VertexEffectPinch(Data2D pinch, Data3D center, Data4D region)
     {
     super(PINCH,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION);
 
-    if( pinch instanceof Dynamic1D)
+    if( pinch instanceof Dynamic2D)
       {
-      mDynamic0 = (Dynamic1D)pinch;
+      mDynamic0 = (Dynamic2D)pinch;
       }
-    else if ( pinch instanceof Static1D )
+    else if ( pinch instanceof Static2D )
       {
-      mStatic0  = (Static1D)pinch;
+      mStatic0  = (Static2D)pinch;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D)
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public VertexEffectPinch(Data1D pinch, Data3D center)
+  public VertexEffectPinch(Data2D pinch, Data3D center)
     {
     super(PINCH,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION);
 
-    if( pinch instanceof Dynamic1D)
+    if( pinch instanceof Dynamic2D)
+      {
+      mDynamic0 = (Dynamic2D)pinch;
+      }
+    else if ( pinch instanceof Static2D )
+      {
+      mStatic0  = (Static2D)pinch;
+      }
+
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret= false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
       {
-      mDynamic0 = (Dynamic1D)pinch;
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
       }
-    else if ( pinch instanceof Static1D )
+    else
       {
-      mStatic0  = (Static1D)pinch;
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
       }
 
-    mCenter = center;
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static2D)mStatic0).getX();
+      uniforms[index+1] = ((Static2D)mStatic0).getY();
+      }
+
+    uniforms[index+1] = (float)(Math.PI*uniforms[index+1]/180);
+
+    return ret;
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSink.java b/src/main/java/org/distorted/library/effect/VertexEffectSink.java
index 61a0453..fb82ae7 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSink.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSink.java
@@ -23,7 +23,11 @@ import org.distorted.library.type.Data1D;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic1D;
+import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static1D;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -49,8 +53,23 @@ public class VertexEffectSink extends VertexEffect
       mStatic0  = (Static1D)sink;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D)
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -68,6 +87,56 @@ public class VertexEffectSink extends VertexEffect
       mStatic0  = (Static1D)sink;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret = false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
+      {
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static1D)mStatic0).getX();
+      }
+
+    return ret;
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
index c69eac8..7d8eddb 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
@@ -23,7 +23,11 @@ import org.distorted.library.type.Data1D;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Dynamic1D;
+import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Static1D;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -49,8 +53,23 @@ public class VertexEffectSwirl extends VertexEffect
       mStatic0  = (Static1D)swirl;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D)
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -68,6 +87,60 @@ public class VertexEffectSwirl extends VertexEffect
       mStatic0  = (Static1D)swirl;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret = false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
+      {
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static1D)mStatic0).getX();
+      }
+
+
+    uniforms[index] = (float)(Math.PI*uniforms[index]/180);
+
+    return ret;
     }
   }
+
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectWave.java b/src/main/java/org/distorted/library/effect/VertexEffectWave.java
index f1a33fb..17d68c6 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectWave.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectWave.java
@@ -22,7 +22,11 @@ package org.distorted.library.effect;
 import org.distorted.library.type.Data3D;
 import org.distorted.library.type.Data4D;
 import org.distorted.library.type.Data5D;
+import org.distorted.library.type.Dynamic3D;
+import org.distorted.library.type.Dynamic4D;
 import org.distorted.library.type.Dynamic5D;
+import org.distorted.library.type.Static3D;
+import org.distorted.library.type.Static4D;
 import org.distorted.library.type.Static5D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -49,8 +53,23 @@ public class VertexEffectWave extends VertexEffect
       mStatic0  = (Static5D)wave;
       }
 
-    mCenter = center;
-    mRegion = region;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D)
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    if( region instanceof Static4D)
+      {
+      mStaticRegion = (Static4D)region;
+      }
+    else if( region instanceof Dynamic4D)
+      {
+      mDynamicRegion = (Dynamic4D)region;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -68,6 +87,64 @@ public class VertexEffectWave extends VertexEffect
       mStatic0  = (Static5D)wave;
       }
 
-    mCenter = center;
+    if( center instanceof Static3D)
+      {
+      mStaticCenter = (Static3D)center;
+      }
+    else if( center instanceof Dynamic3D )
+      {
+      mDynamicCenter = (Dynamic3D)center;
+      }
+
+    mStaticRegion = new Static4D(0,0,Float.MAX_VALUE, Float.MAX_VALUE);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean compute(float[] uniforms, int index, long currentDuration, long step )
+    {
+    boolean ret = false;
+
+    if( mDynamicCenter!=null )
+      {
+      mDynamicCenter.interpolateMain(uniforms,index+5,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+5] = mStaticCenter.getX();
+      uniforms[index+6] = mStaticCenter.getY();
+      uniforms[index+7] = mStaticCenter.getZ();
+      }
+
+    if( mDynamicRegion!=null )
+      {
+      mDynamicRegion.interpolateMain(uniforms,index+8,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index+ 8] = mStaticRegion.getX();
+      uniforms[index+ 9] = mStaticRegion.getY();
+      uniforms[index+10] = mStaticRegion.getZ();
+      uniforms[index+11] = mStaticRegion.getW();
+      }
+
+    if( mDynamic0!=null )
+      {
+      ret = mDynamic0.interpolateMain(uniforms,index,currentDuration,step);
+      }
+    else
+      {
+      uniforms[index  ] = ((Static5D)mStatic0).getX();
+      uniforms[index+1] = ((Static5D)mStatic0).getY();
+      uniforms[index+2] = ((Static5D)mStatic0).getZ();
+      uniforms[index+3] = ((Static5D)mStatic0).getW();
+      uniforms[index+4] = ((Static5D)mStatic0).getV();
+      }
+
+    uniforms[index+2] = (float)(Math.PI*uniforms[index+2]/180);
+    uniforms[index+3] = (float)(Math.PI*uniforms[index+3]/180);
+    uniforms[index+4] = (float)(Math.PI*uniforms[index+4]/180);
+
+    return ret;
     }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectMessageSender.java b/src/main/java/org/distorted/library/main/EffectMessageSender.java
index 1155f20..657dc60 100644
--- a/src/main/java/org/distorted/library/main/EffectMessageSender.java
+++ b/src/main/java/org/distorted/library/main/EffectMessageSender.java
@@ -33,16 +33,14 @@ final class EffectMessageSender extends Thread
     EffectListener mListener;
     EffectMessage mMessage;
     long mEffectID;
-    int mEffectName;
-    long mBitmapID;
+    long mObjectID;
 
-    Message(EffectListener l, EffectMessage m, long id, int name, long bmpID)
+    Message(EffectListener l, EffectMessage m, long effID, long objID)
       {
-      mListener   = l;
-      mMessage    = m;
-      mEffectID   = id;
-      mEffectName = name;
-      mBitmapID   = bmpID;
+      mListener = l;
+      mMessage  = m;
+      mEffectID = effID;
+      mObjectID = objID;
       }
     }
   
@@ -106,7 +104,7 @@ final class EffectMessageSender extends Thread
       while( mList.size()>0 )
         {
         tmp = mList.remove(0);
-        tmp.mListener.effectMessage(tmp.mMessage, tmp.mEffectID, tmp.mEffectName,tmp.mBitmapID);
+        tmp.mListener.effectMessage(tmp.mMessage, tmp.mEffectID, tmp.mObjectID);
         }
 
       synchronized(mThis)
@@ -128,9 +126,9 @@ final class EffectMessageSender extends Thread
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
         
-  static void newMessage(EffectListener l, EffectMessage m, long id, int name, long bmpID)
+  static void newMessage(EffectListener l, EffectMessage m, long effID, long objID)
     {
-    Message msg = mThis.new Message(l,m,id,name,bmpID);
+    Message msg = mThis.new Message(l,m,effID,objID);
     mList.add(msg);
 
     synchronized(mThis)
@@ -140,4 +138,3 @@ final class EffectMessageSender extends Thread
       }
     }
   }
-///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/main/EffectQueue.java b/src/main/java/org/distorted/library/main/EffectQueue.java
index 611a711..9faf9ff 100644
--- a/src/main/java/org/distorted/library/main/EffectQueue.java
+++ b/src/main/java/org/distorted/library/main/EffectQueue.java
@@ -22,7 +22,6 @@ package org.distorted.library.main;
 import org.distorted.library.effect.Effect;
 import org.distorted.library.message.EffectListener;
 import org.distorted.library.message.EffectMessage;
-import org.distorted.library.type.Dynamic;
 
 import java.util.Vector;
 
@@ -30,25 +29,20 @@ import java.util.Vector;
 
 abstract class EffectQueue
   {
-  protected byte mNumEffects;   // number of effects at the moment
-  protected long mTotalEffects; // total number of effects ever created
-  protected int[] mName;
-  protected int[] mType;
+  protected byte mNumEffects;
   protected float[] mUniforms;
-  protected float[] mCache;
-  protected Dynamic[][] mInter;
   protected long[] mCurrentDuration;
-  protected byte[] mFreeIndexes;
-  protected byte[] mIDIndex;
-  protected long[] mID;
+  protected Effect[] mEffects;
+  protected int[] mName;
   protected long mTime=0;
   protected static int[] mMax = new int[Effect.LENGTH];
-  protected int mMaxIndex;
   protected Vector<EffectListener> mListeners =null;
   protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
-  protected long mObjectID;
+  protected long mID;
 
   private static boolean mCreated;
+  private int mIndex;
+  private int mNumUniforms;
 
   static
     {
@@ -57,32 +51,21 @@ abstract class EffectQueue
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
-  EffectQueue(long id, int numUniforms, int numCache, int index)
+  EffectQueue(long id, int numUniforms, int index)
     {
-    mNumEffects   = 0;
-    mTotalEffects = 0;
-    mMaxIndex     = index;
-    mObjectID     = id;
+    mNumEffects  = 0;
+    mID          = id;
+    mIndex       = index;
+    mNumUniforms = numUniforms;
 
-    int max = mMax[mMaxIndex];
+    int max = mMax[mIndex];
 
     if( max>0 )
       {
-      mName            = new int[max];
-      mType            = new int[max];
-      mUniforms        = new float[numUniforms*max];
-      mInter           = new Dynamic[3][max];
+      mUniforms        = new float[mNumUniforms*max];
       mCurrentDuration = new long[max];
-      mID              = new long[max];
-      mIDIndex         = new byte[max];
-      mFreeIndexes     = new byte[max];
-     
-      for(byte i=0; i<max; i++) mFreeIndexes[i] = i;
-
-      if( numCache>0 )
-        {
-        mCache = new float[numCache*max];
-        }
+      mEffects         = new Effect[max];
+      mName            = new int[max];
       }
    
     mCreated = true;  
@@ -152,33 +135,16 @@ abstract class EffectQueue
     Effect.reset(mMax);
     mCreated = false;  
     }
- 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  synchronized int removeByID(long id)
-    {
-    int i = getEffectIndex(id);
-   
-    if( i>=0 ) 
-      {
-      remove(i);
-      return 1;
-      }
-   
-    return 0;
-    }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   synchronized int removeByType(Effect effect)
     {
-    int ret  = 0;
-    int name = effect.getName();
-    int type = effect.getType();
+    int ret = 0;
 
     for(int i=0; i<mNumEffects; i++)
       {
-      if( mName[i]==name && mType[i]==type )
+      if( mEffects[i]==effect )
         {
         remove(i);
         i--;
@@ -188,14 +154,6 @@ abstract class EffectQueue
    
     return ret;
     }
-  
-///////////////////////////////////////////////////////////////////////////////////////////////////
-  
-  private synchronized int getEffectIndex(long id)
-    {
-    int index = mIDIndex[(int)(id%mMax[mMaxIndex])];
-    return (index<mNumEffects && mID[index]==id ? index : -1);
-    }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // we do want to notify Listeners if they called 'abortAll' themselves but don't want to notify
@@ -204,28 +162,16 @@ abstract class EffectQueue
   synchronized int abortAll(boolean notify)
     {
     int ret = mNumEffects;
-    long removedID;
-    int removedName, removedType;
 
     for(int i=0; i<ret; i++ )
       {
-      mInter[0][i] = null;
-      mInter[1][i] = null;
-      mInter[2][i] = null;
-
       if( notify )
         {
-        removedID = mID[i];
-        removedName= mName[i];
-        removedType= mType[i];
-
         for(int j=0; j<mNumListeners; j++)
-          EffectMessageSender.newMessage( mListeners.elementAt(j),
-                                          EffectMessage.EFFECT_REMOVED,
-                                          (removedID<<Effect.LENGTH)+removedType,
-                                          removedName,
-                                          mObjectID);
+          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_REMOVED, mEffects[i].getID(), mID);
         }
+
+      mEffects[i] = null;
       }
 
     mNumEffects= 0;
@@ -239,128 +185,35 @@ abstract class EffectQueue
   protected void remove(int effect)
     {
     mNumEffects--;     
-    
-    byte removedIndex = (byte)(mID[effect]%mMax[mMaxIndex]);
-    byte removedPosition = mIDIndex[removedIndex];
-    mFreeIndexes[mNumEffects] = removedIndex;
-    
-    long removedID = mID[effect];
-    int removedName= mName[effect];
-    int removedType= mType[effect];
-
-    for(int j=0; j<mMax[mMaxIndex]; j++)
-      {
-      if( mIDIndex[j] > removedPosition ) mIDIndex[j]--; 
-      }
-         
+
+    long removedID = mEffects[effect].getID();
+
     for(int j=effect; j<mNumEffects; j++ ) 
       {
-      mName[j]            = mName[j+1];
-      mType[j]            = mType[j+1];
-      mInter[0][j]        = mInter[0][j+1];
-      mInter[1][j]        = mInter[1][j+1];
-      mInter[2][j]        = mInter[2][j+1];
+      mEffects[j]         = mEffects[j+1];
       mCurrentDuration[j] = mCurrentDuration[j+1];
-      mID[j]              = mID[j+1];
-    
-      moveEffect(j);
+      mName[j]            = mName[j+1];
+
+      for(int k=0; k<mNumUniforms; k++)
+        mUniforms[mNumUniforms*j+k] = mUniforms[mNumUniforms*(j+1)+k];
       }
    
-    mInter[0][mNumEffects] = null;
-    mInter[1][mNumEffects] = null;
-    mInter[2][mNumEffects] = null;
+    mEffects[mNumEffects] = null;
 
     for(int i=0; i<mNumListeners; i++) 
-      EffectMessageSender.newMessage( mListeners.elementAt(i),
-                                      EffectMessage.EFFECT_REMOVED,
-                                      (removedID<<Effect.LENGTH)+removedType,
-                                      removedName,
-                                      mObjectID);
+      EffectMessageSender.newMessage( mListeners.elementAt(i), EffectMessage.EFFECT_REMOVED, removedID, mID);
     }
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   
-  protected long addBase(Effect effect)
+  public void add(Effect effect)
     {
-    int type = effect.getType();
-
-    mName[mNumEffects] = effect.getName();
-    mType[mNumEffects] = type;
-    mCurrentDuration[mNumEffects] = 0;
-    
-    int index = mFreeIndexes[mNumEffects];
-    long id = mTotalEffects*mMax[mMaxIndex] + index;
-    mID[mNumEffects] = id;
-    mIDIndex[index] = mNumEffects;  
-   
-    mNumEffects++; 
-    mTotalEffects++;
-   
-    return (id<<Effect.LENGTH)+type;
-    }
-    
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// used only for debugging
-
-  @SuppressWarnings("unused")
-  protected String printEffects(int max)
-    {
-    long[] indexes = new long[mMax[mMaxIndex]];
-   
-    for(int g=0; g<mMax[mMaxIndex]; g++)
-      {
-      indexes[g] = -1;  
-      }
-   
-    String ret="(";
-    int f;
-   
-    for(int g=0; g<max; g++) 
+    if( mMax[mIndex]>mNumEffects )
       {
-      f = getEffectIndex(g);
-      if( f>=0 ) indexes[f] = g;
+      mCurrentDuration[mNumEffects] = 0;
+      mEffects[mNumEffects] = effect;
+      mName[mNumEffects] = effect.getName();
+      mNumEffects++;
       }
-   
-    for(int g=0; g<mMax[mMaxIndex]; g++)
-      {
-      ret += (g>0 ? ",":"")+(indexes[g]>=0 ? indexes[g] : " ");   
-      }
-   
-    ret += ")";
-   
-    return ret;
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Only used for debugging
-  
-  protected boolean printByID(long id)
-    {
-    int index = getEffectIndex(id);
-   
-    if( index>=0 ) 
-      {
-      boolean inter0 = mInter[0][index]==null;
-      boolean inter1 = mInter[1][index]==null;
-      boolean inter2 = mInter[2][index]==null;
-
-      android.util.Log.e("EffectQueue", "numEffects="+mNumEffects+" effect id="+id+" index="+index+
-                         " duration="+mCurrentDuration[index]+" inter[0] null="+inter0+" inter[1] null="+inter1+" inter[2] null="+inter2);
-
-      if( !inter0 ) android.util.Log.e("EffectQueue","inter[0]: "+mInter[0][index].print());
-      if( !inter1 ) android.util.Log.e("EffectQueue","inter[1]: "+mInter[1][index].print());
-      if( !inter2 ) android.util.Log.e("EffectQueue","inter[2]: "+mInter[2][index].print());
-
-      return true;
-      }
-   
-    android.util.Log.e("EffectQueue", "effect id="+id+" not found");
-
-    return false;  
-    }
- 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  abstract void moveEffect(int index);
   }
-///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/main/EffectQueueFragment.java b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
index 120a439..e7dfb2b 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueFragment.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
@@ -24,30 +24,22 @@ import android.opengl.GLES30;
 import org.distorted.library.effect.Effect;
 import org.distorted.library.effect.FragmentEffect;
 import org.distorted.library.message.EffectMessage;
-import org.distorted.library.type.Dynamic4D;
-import org.distorted.library.type.Static;
-import org.distorted.library.type.Static1D;
-import org.distorted.library.type.Static2D;
-import org.distorted.library.type.Static3D;
-import org.distorted.library.type.Static4D;
-import org.distorted.library.type.Static5D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class EffectQueueFragment extends EffectQueue
   {
-  private static final int NUM_UNIFORMS = 8;
-  private static final int NUM_CACHE    = 4;
+  private static final int NUM_UNIFORMS = FragmentEffect.NUM_UNIFORMS;
   private static final int INDEX = Effect.FRAGMENT;
   private static int mNumEffectsH;
-  private static int mTypeH;
+  private static int mNameH;
   private static int mUniformsH;
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
   EffectQueueFragment(long id)
     { 
-    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX);
+    super(id,NUM_UNIFORMS,INDEX);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -55,7 +47,7 @@ class EffectQueueFragment extends EffectQueue
   static void getUniforms(int mProgramH)
     {
     mNumEffectsH= GLES30.glGetUniformLocation( mProgramH, "fNumEffects");
-    mTypeH      = GLES30.glGetUniformLocation( mProgramH, "fType");
+    mNameH      = GLES30.glGetUniformLocation( mProgramH, "fName");
     mUniformsH  = GLES30.glGetUniformLocation( mProgramH, "fUniforms");
     }
 
@@ -66,51 +58,24 @@ class EffectQueueFragment extends EffectQueue
     if( currTime==mTime ) return;
     if( mTime==0 ) mTime = currTime;
     long step = (currTime-mTime);
-   
+
     for(int i=0; i<mNumEffects; i++)
       {
       mCurrentDuration[i] += step;
 
-      if( mInter[0][i]!=null && mInter[0][i].interpolateMain(mUniforms ,NUM_UNIFORMS*i, mCurrentDuration[i], step) )
+      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
         {
-        for(int j=0; j<mNumListeners; j++)   
-          EffectMessageSender.newMessage( mListeners.elementAt(j),
-                                          EffectMessage.EFFECT_FINISHED,
-                                          (mID[i]<<Effect.LENGTH)+Effect.FRAGMENT,
-                                          mName[i],
-                                          mObjectID);
-      
-        if( FragmentEffect.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
-          {
-          remove(i);
-          i--;
-          continue;
-          }
-        else mInter[0][i] = null;
-        }
+        for(int j=0; j<mNumListeners; j++)
+          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-      if( mInter[1][i]!=null ) mInter[2][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
-      if( mInter[2][i]!=null ) mInter[1][i].interpolateMain( mCache   , NUM_CACHE*i     , mCurrentDuration[i], step);
+        if( FragmentEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+          remove(i--);
+        }
       }
-   
+
     mTime = currTime;  
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  protected void moveEffect(int index)
-    {
-    mUniforms[NUM_UNIFORMS*index  ] = mUniforms[NUM_UNIFORMS*(index+1)  ];
-    mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];
-    mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];
-    mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];
-
-    mCache[NUM_CACHE*index  ] = mCache[NUM_CACHE*(index+1)  ];
-    mCache[NUM_CACHE*index+1] = mCache[NUM_CACHE*(index+1)+1];
-    mCache[NUM_CACHE*index+2] = mCache[NUM_CACHE*(index+1)+2];
-    mCache[NUM_CACHE*index+3] = mCache[NUM_CACHE*(index+1)+3];
-    }
-  
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   
   synchronized void send(float halfX, float halfY)
@@ -121,93 +86,12 @@ class EffectQueueFragment extends EffectQueue
       {
       for(int i=0; i<mNumEffects; i++)
         {
-        mUniforms[NUM_UNIFORMS*i+4] = mCache[NUM_CACHE*i  ]-halfX;
-        mUniforms[NUM_UNIFORMS*i+5] =-mCache[NUM_CACHE*i+1]+halfY;
-        mUniforms[NUM_UNIFORMS*i+6] = mCache[NUM_CACHE*i+2];
-        mUniforms[NUM_UNIFORMS*i+7] = mCache[NUM_CACHE*i+3];
+        mUniforms[NUM_UNIFORMS*i+4] = mUniforms[NUM_UNIFORMS*i+4]-halfX;
+        mUniforms[NUM_UNIFORMS*i+5] =-mUniforms[NUM_UNIFORMS*i+5]+halfY;
         }
 
-      GLES30.glUniform1iv( mTypeH    ,                 mNumEffects, mName    ,0);
+      GLES30.glUniform1iv( mNameH    ,                 mNumEffects, mName    ,0);
       GLES30.glUniform4fv( mUniformsH,(NUM_UNIFORMS/4)*mNumEffects, mUniforms,0);
       }  
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  synchronized long add(FragmentEffect fe)
-    {
-    if( mMax[INDEX]>mNumEffects )
-      {
-      int dim0 = 0;
-
-      if( fe.mDynamic0 != null )
-        {
-        mInter[0][mNumEffects] = fe.mDynamic0;
-        dim0 = fe.mDynamic0.getDimension();
-        }
-      else
-        {
-        mInter[0][mNumEffects] = null;
-
-        if( fe.mStatic0 != null )
-          {
-          Static s = fe.mStatic0;
-          dim0 = s.getDimension();
-
-          switch( dim0 )
-            {
-            case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + 4] = ((Static5D)s).getV();
-            case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + 3] = ((Static4D)s).getW();
-            case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + 2] = ((Static3D)s).getZ();
-            case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + 1] = ((Static2D)s).getY();
-            case 1 : mUniforms[NUM_UNIFORMS*mNumEffects    ] = ((Static1D)s).getX();
-            }
-          }
-        }
-
-      if( fe.mDynamic1 != null )
-        {
-        mInter[1][mNumEffects] = fe.mDynamic1;
-        }
-      else
-        {
-        mInter[1][mNumEffects] = null;
-
-        if( fe.mStatic1 != null )
-          {
-          Static s = fe.mStatic1;
-          int dim1 = s.getDimension();
-
-          switch( dim1 )
-            {
-            case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 4] = ((Static5D)s).getV();
-            case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 3] = ((Static4D)s).getW();
-            case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 2] = ((Static3D)s).getZ();
-            case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 1] = ((Static2D)s).getY();
-            case 1 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0    ] = ((Static1D)s).getX();
-            }
-          }
-        }
-
-      if( fe.mRegion instanceof Dynamic4D)
-        {
-        mInter[2][mNumEffects] = (Dynamic4D)fe.mRegion;
-        }
-      else if( fe.mRegion instanceof Static4D )
-        {
-        mInter[2][mNumEffects]  = null;
-
-        Static4D s = (Static4D)fe.mRegion;
-        mCache[NUM_CACHE*mNumEffects  ] = s.getX();
-        mCache[NUM_CACHE*mNumEffects+1] = s.getY();
-        mCache[NUM_CACHE*mNumEffects+2] = s.getZ();
-        mCache[NUM_CACHE*mNumEffects+3] = s.getW();
-        }
-      else return -1;
-
-      return addBase(fe);
-      }
-      
-    return -1;
-    }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
index 8aed83d..fa2cdfa 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
@@ -25,20 +25,12 @@ import android.opengl.Matrix;
 import org.distorted.library.effect.Effect;
 import org.distorted.library.effect.MatrixEffect;
 import org.distorted.library.message.EffectMessage;
-import org.distorted.library.type.Dynamic3D;
-import org.distorted.library.type.Static;
-import org.distorted.library.type.Static1D;
-import org.distorted.library.type.Static2D;
-import org.distorted.library.type.Static3D;
-import org.distorted.library.type.Static4D;
-import org.distorted.library.type.Static5D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class EffectQueueMatrix extends EffectQueue
   {   
-  private static final int NUM_UNIFORMS = 7;
-  private static final int NUM_CACHE    = 0;
+  private static final int NUM_UNIFORMS = MatrixEffect.NUM_UNIFORMS;
   private static final int INDEX = Effect.MATRIX;
 
   private static float[] mMVPMatrix = new float[16];
@@ -53,7 +45,7 @@ class EffectQueueMatrix extends EffectQueue
    
   EffectQueueMatrix(long id)
     { 
-    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX );
+    super(id,NUM_UNIFORMS,INDEX );
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -216,70 +208,63 @@ class EffectQueueMatrix extends EffectQueue
 
     for(int i=0; i<mNumEffects; i++)
       {
-      if (mName[i] == MatrixEffect.ROTATE )
+      switch( mEffects[i].getName() )
         {
-        x = mUniforms[NUM_UNIFORMS*i+4];
-        y = mUniforms[NUM_UNIFORMS*i+5];
-        z = mUniforms[NUM_UNIFORMS*i+6];
-
-        Matrix.translateM(mViewMatrix, 0, x,-y, z);
-        Matrix.rotateM( mViewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-        Matrix.translateM(mViewMatrix, 0,-x, y,-z);
-        }
-      else if(mName[i] == MatrixEffect.QUATERNION )
-        {
-        x = mUniforms[NUM_UNIFORMS*i+4];
-        y = mUniforms[NUM_UNIFORMS*i+5];
-        z = mUniforms[NUM_UNIFORMS*i+6];
-
-        Matrix.translateM(mViewMatrix, 0, x,-y, z);
-        multiplyByQuat(mViewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-        Matrix.translateM(mViewMatrix, 0,-x, y,-z);
-        }
-      else if(mName[i] == MatrixEffect.MOVE )
-        {
-        sx = mUniforms[NUM_UNIFORMS*i  ];
-        sy = mUniforms[NUM_UNIFORMS*i+1];
-        sz = mUniforms[NUM_UNIFORMS*i+2];
-
-        Matrix.translateM(mViewMatrix, 0, sx,-sy, sz);
-        }
-      else if(mName[i] == MatrixEffect.SCALE )
-        {
-        sx = mUniforms[NUM_UNIFORMS*i  ];
-        sy = mUniforms[NUM_UNIFORMS*i+1];
-        sz = mUniforms[NUM_UNIFORMS*i+2];
-
-        Matrix.scaleM(mViewMatrix, 0, sx, sy, sz);
-        }
-      else if(mName[i] == MatrixEffect.SHEAR )
-        {
-        sx = mUniforms[NUM_UNIFORMS*i  ];
-        sy = mUniforms[NUM_UNIFORMS*i+1];
-        sz = mUniforms[NUM_UNIFORMS*i+2];
-
-        x  = mUniforms[NUM_UNIFORMS*i+4];
-        y  = mUniforms[NUM_UNIFORMS*i+5];
-        z  = mUniforms[NUM_UNIFORMS*i+6];
-
-        Matrix.translateM(mViewMatrix, 0, x,-y, z);
-
-        mViewMatrix[4] += sx*mViewMatrix[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear.
-        mViewMatrix[5] += sx*mViewMatrix[1]; //                        0 1 0 0
-        mViewMatrix[6] += sx*mViewMatrix[2]; //                        0 0 1 0
-        mViewMatrix[7] += sx*mViewMatrix[3]; //                        0 0 0 1
-
-        mViewMatrix[0] += sy*mViewMatrix[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear.
-        mViewMatrix[1] += sy*mViewMatrix[5]; //                        y 1 0 0
-        mViewMatrix[2] += sy*mViewMatrix[6]; //                        0 0 1 0
-        mViewMatrix[3] += sy*mViewMatrix[7]; //                        0 0 0 1
-
-        mViewMatrix[4] += sz*mViewMatrix[8]; // Multiply viewMatrix by 1 0 0 0 , i.e. Z-shear.
-        mViewMatrix[5] += sz*mViewMatrix[9]; //                        0 1 0 0
-        mViewMatrix[6] += sz*mViewMatrix[10];//                        0 z 1 0
-        mViewMatrix[7] += sz*mViewMatrix[11];//                        0 0 0 1
-
-        Matrix.translateM(mViewMatrix, 0,-x, y, -z);
+        case MatrixEffect.ROTATE     : x = mUniforms[NUM_UNIFORMS*i+4];
+                                       y = mUniforms[NUM_UNIFORMS*i+5];
+                                       z = mUniforms[NUM_UNIFORMS*i+6];
+
+                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
+                                       Matrix.rotateM( mViewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
+                                       Matrix.translateM(mViewMatrix, 0,-x, y,-z);
+                                       break;
+        case MatrixEffect.QUATERNION : x = mUniforms[NUM_UNIFORMS*i+4];
+                                       y = mUniforms[NUM_UNIFORMS*i+5];
+                                       z = mUniforms[NUM_UNIFORMS*i+6];
+
+                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
+                                       multiplyByQuat(mViewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
+                                       Matrix.translateM(mViewMatrix, 0,-x, y,-z);
+                                       break;
+        case MatrixEffect.MOVE       : sx = mUniforms[NUM_UNIFORMS*i  ];
+                                       sy = mUniforms[NUM_UNIFORMS*i+1];
+                                       sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                                       Matrix.translateM(mViewMatrix, 0, sx,-sy, sz);
+                                       break;
+        case MatrixEffect.SCALE      : sx = mUniforms[NUM_UNIFORMS*i  ];
+                                       sy = mUniforms[NUM_UNIFORMS*i+1];
+                                       sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                                       Matrix.scaleM(mViewMatrix, 0, sx, sy, sz);
+                                       break;
+        case MatrixEffect.SHEAR      : sx = mUniforms[NUM_UNIFORMS*i  ];
+                                       sy = mUniforms[NUM_UNIFORMS*i+1];
+                                       sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                                       x  = mUniforms[NUM_UNIFORMS*i+4];
+                                       y  = mUniforms[NUM_UNIFORMS*i+5];
+                                       z  = mUniforms[NUM_UNIFORMS*i+6];
+
+                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
+
+                                       mViewMatrix[4] += sx*mViewMatrix[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear.
+                                       mViewMatrix[5] += sx*mViewMatrix[1]; //                        0 1 0 0
+                                       mViewMatrix[6] += sx*mViewMatrix[2]; //                        0 0 1 0
+                                       mViewMatrix[7] += sx*mViewMatrix[3]; //                        0 0 0 1
+
+                                       mViewMatrix[0] += sy*mViewMatrix[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear.
+                                       mViewMatrix[1] += sy*mViewMatrix[5]; //                        y 1 0 0
+                                       mViewMatrix[2] += sy*mViewMatrix[6]; //                        0 0 1 0
+                                       mViewMatrix[3] += sy*mViewMatrix[7]; //                        0 0 0 1
+
+                                       mViewMatrix[4] += sz*mViewMatrix[8]; // Multiply viewMatrix by 1 0 0 0 , i.e. Z-shear.
+                                       mViewMatrix[5] += sz*mViewMatrix[9]; //                        0 1 0 0
+                                       mViewMatrix[6] += sz*mViewMatrix[10];//                        0 z 1 0
+                                       mViewMatrix[7] += sz*mViewMatrix[11];//                        0 0 0 1
+
+                                       Matrix.translateM(mViewMatrix, 0,-x, y, -z);
+                                       break;
         }
       }
 
@@ -306,51 +291,24 @@ class EffectQueueMatrix extends EffectQueue
     if( currTime==mTime ) return;
     if( mTime==0 ) mTime = currTime;
     long step = (currTime-mTime);
-   
+
     for(int i=0; i<mNumEffects; i++)
       {
       mCurrentDuration[i] += step;
 
-      if( mInter[0][i]!=null && mInter[0][i].interpolateMain(mUniforms ,NUM_UNIFORMS*i, mCurrentDuration[i], step) )
+      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
         {
         for(int j=0; j<mNumListeners; j++)
-          EffectMessageSender.newMessage( mListeners.elementAt(j),
-                                          EffectMessage.EFFECT_FINISHED,
-                                         (mID[i]<<Effect.LENGTH)+Effect.MATRIX,
-                                          mName[i],
-                                          mObjectID);
-
-        if( MatrixEffect.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
-          {
-          remove(i);
-          i--;
-          continue;
-          }
-        else mInter[0][i] = null;
-        }
+          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-      if( mInter[2][i]!=null )
-        {
-        mInter[2][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+4, mCurrentDuration[i], step);
+        if( MatrixEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+          remove(i--);
         }
       }
      
     mTime = currTime;  
     }  
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  protected void moveEffect(int index)
-    {
-    mUniforms[NUM_UNIFORMS*index  ] = mUniforms[NUM_UNIFORMS*(index+1)  ];
-    mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];
-    mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];
-    mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];
-    mUniforms[NUM_UNIFORMS*index+4] = mUniforms[NUM_UNIFORMS*(index+1)+4];
-    mUniforms[NUM_UNIFORMS*index+5] = mUniforms[NUM_UNIFORMS*(index+1)+5];
-    mUniforms[NUM_UNIFORMS*index+6] = mUniforms[NUM_UNIFORMS*(index+1)+6];
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   float[] getMVP()
@@ -368,75 +326,4 @@ class EffectQueueMatrix extends EffectQueue
     GLES30.glUniformMatrix4fv(mMVMatrixH , 1, false, mViewMatrix, 0);
     GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix , 0);
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  synchronized long add(MatrixEffect me)
-    {
-    if( mMax[INDEX]>mNumEffects )
-      {
-      int dim0 = 0;
-
-      if( me.mDynamic0 != null )
-        {
-        mInter[0][mNumEffects] = me.mDynamic0;
-        dim0 = me.mDynamic0.getDimension();
-        }
-      else
-        {
-        mInter[0][mNumEffects] = null;
-
-        if( me.mStatic0 != null )
-          {
-          Static s = me.mStatic0;
-          dim0 = s.getDimension();
-
-          switch( dim0 )
-            {
-            case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + 4] = ((Static5D)s).getV();
-            case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + 3] = ((Static4D)s).getW();
-            case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + 2] = ((Static3D)s).getZ();
-            case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + 1] = ((Static2D)s).getY();
-            case 1 : mUniforms[NUM_UNIFORMS*mNumEffects    ] = ((Static1D)s).getX();
-            }
-          }
-        }
-
-      mInter[1][mNumEffects] = null;
-
-      if( me.mStatic1 != null )
-        {
-        Static s = me.mStatic1;
-        int dim1 = s.getDimension();
-
-        switch( dim1 )
-          {
-          case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 4] = ((Static5D)s).getV();
-          case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 3] = ((Static4D)s).getW();
-          case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 2] = ((Static3D)s).getZ();
-          case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 1] = ((Static2D)s).getY();
-          case 1 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0    ] = ((Static1D)s).getX();
-          }
-        }
-
-      if( me.mCenter instanceof Dynamic3D)
-        {
-        mInter[2][mNumEffects] = (Dynamic3D)me.mCenter;
-        }
-      else if( me.mCenter instanceof Static3D )
-        {
-        mInter[2][mNumEffects] = null;
-
-        Static3D s = (Static3D)me.mCenter;
-        mUniforms[NUM_UNIFORMS*mNumEffects+4] = s.getX();
-        mUniforms[NUM_UNIFORMS*mNumEffects+5] = s.getY();
-        mUniforms[NUM_UNIFORMS*mNumEffects+6] = s.getZ();
-        }
-      else return -1;
-
-      return addBase(me);
-      }
-      
-    return -1;
-    }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
index 79109c4..fe5bfc4 100644
--- a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
+++ b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
@@ -32,12 +32,6 @@ import org.distorted.library.program.FragmentUniformsException;
 import org.distorted.library.program.LinkingException;
 import org.distorted.library.program.VertexCompilationException;
 import org.distorted.library.program.VertexUniformsException;
-import org.distorted.library.type.Static;
-import org.distorted.library.type.Static1D;
-import org.distorted.library.type.Static2D;
-import org.distorted.library.type.Static3D;
-import org.distorted.library.type.Static4D;
-import org.distorted.library.type.Static5D;
 
 import java.io.InputStream;
 import java.nio.ByteBuffer;
@@ -53,8 +47,7 @@ class EffectQueuePostprocess extends EffectQueue
   private static final int POS_DATA_SIZE= 2; // Post Program: size of the position data in elements
   private static final int TEX_DATA_SIZE= 2; // Post Program: size of the texture coordinate data in elements.
 
-  private static final int NUM_UNIFORMS = 5;
-  private static final int NUM_CACHE    = 0;
+  private static final int NUM_UNIFORMS = PostprocessEffect.NUM_UNIFORMS;
   private static final int INDEX = Effect.POSTPROCESS;
 
   private static final FloatBuffer mQuadPositions, mQuadTexture, mQuadTextureInv;
@@ -118,7 +111,7 @@ class EffectQueuePostprocess extends EffectQueue
 
   EffectQueuePostprocess(long id)
     { 
-    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX );
+    super(id,NUM_UNIFORMS,INDEX );
 
     mQualityLevel = 0;
     mQualityScale = 1.0f;
@@ -177,9 +170,9 @@ class EffectQueuePostprocess extends EffectQueue
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean compute(long currTime)
+  private synchronized void compute(long currTime)
     {
-    if( currTime==mTime ) return false;
+    if( currTime==mTime ) return;
     if( mTime==0 ) mTime = currTime;
     long step = (currTime-mTime);
 
@@ -190,44 +183,23 @@ class EffectQueuePostprocess extends EffectQueue
       {
       mCurrentDuration[i] += step;
 
-      if( mInter[0][i]!=null && mInter[0][i].interpolateMain(mUniforms ,NUM_UNIFORMS*i, mCurrentDuration[i], step) )
+      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
         {
         for(int j=0; j<mNumListeners; j++)
-          EffectMessageSender.newMessage( mListeners.elementAt(j),
-                                          EffectMessage.EFFECT_FINISHED,
-                                         (mID[i]<<Effect.LENGTH)+Effect.POSTPROCESS,
-                                          mName[i],
-                                          mObjectID);
+          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-        if( PostprocessEffect.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
+        if( PostprocessEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
           {
-          remove(i);
-          i--;
+          remove(i--);
           continue;
           }
-        else mInter[0][i] = null;
         }
 
-      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
-
       halo = (int)mUniforms[NUM_UNIFORMS*i];
       if( halo>mHalo ) mHalo = halo;
       }
 
     mTime = currTime;
-
-    return true;
-    }  
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  protected void moveEffect(int index)
-    {
-    mUniforms[NUM_UNIFORMS*index  ] = mUniforms[NUM_UNIFORMS*(index+1)  ];
-    mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];
-    mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];
-    mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];
-    mUniforms[NUM_UNIFORMS*index+4] = mUniforms[NUM_UNIFORMS*(index+1)+4];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -383,60 +355,4 @@ class EffectQueuePostprocess extends EffectQueue
     {
 
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  synchronized long add(PostprocessEffect pe)
-    {
-    if( mMax[INDEX]>mNumEffects )
-      {
-      int dim0 = 0;
-
-      if( pe.mDynamic0 != null )
-        {
-        mInter[0][mNumEffects] = pe.mDynamic0;
-        dim0 = pe.mDynamic0.getDimension();
-        }
-      else
-        {
-        mInter[0][mNumEffects] = null;
-
-        if( pe.mStatic0 != null )
-          {
-          Static s = pe.mStatic0;
-          dim0 = s.getDimension();
-
-          switch( dim0 )
-            {
-            case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + 4] = ((Static5D)s).getV();
-            case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + 3] = ((Static4D)s).getW();
-            case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + 2] = ((Static3D)s).getZ();
-            case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + 1] = ((Static2D)s).getY();
-            case 1 : mUniforms[NUM_UNIFORMS*mNumEffects    ] = ((Static1D)s).getX();
-            }
-          }
-        }
-
-      mInter[1][mNumEffects] = null;
-
-      if( pe.mStatic1 != null )
-        {
-        Static s = pe.mStatic1;
-        int dim1 = s.getDimension();
-
-        switch( dim1 )
-          {
-          case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 4] = ((Static5D)s).getV();
-          case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 3] = ((Static4D)s).getW();
-          case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 2] = ((Static3D)s).getZ();
-          case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0 + 1] = ((Static2D)s).getY();
-          case 1 : mUniforms[NUM_UNIFORMS*mNumEffects + dim0    ] = ((Static1D)s).getX();
-          }
-        }
-
-      return addBase(pe);
-      }
-
-    return -1;
-    }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueueVertex.java b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
index a56a53a..ae11468 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueVertex.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
@@ -24,31 +24,22 @@ import android.opengl.GLES30;
 import org.distorted.library.effect.Effect;
 import org.distorted.library.effect.VertexEffect;
 import org.distorted.library.message.EffectMessage;
-import org.distorted.library.type.Dynamic3D;
-import org.distorted.library.type.Dynamic4D;
-import org.distorted.library.type.Static;
-import org.distorted.library.type.Static1D;
-import org.distorted.library.type.Static2D;
-import org.distorted.library.type.Static3D;
-import org.distorted.library.type.Static4D;
-import org.distorted.library.type.Static5D;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class EffectQueueVertex extends EffectQueue
   { 
-  private static final int NUM_UNIFORMS = 12;
-  private static final int NUM_CACHE    =  3;
+  private static final int NUM_UNIFORMS = VertexEffect.NUM_UNIFORMS;
   private static final int INDEX = Effect.VERTEX;
   private static int mNumEffectsH;
-  private static int mTypeH;
+  private static int mNameH;
   private static int mUniformsH;
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////
    
   EffectQueueVertex(long id)
     { 
-    super(id,NUM_UNIFORMS,NUM_CACHE,INDEX);
+    super(id,NUM_UNIFORMS,INDEX);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -56,7 +47,7 @@ class EffectQueueVertex extends EffectQueue
   static void getUniforms(int mProgramH)
     {
     mNumEffectsH= GLES30.glGetUniformLocation( mProgramH, "vNumEffects");
-    mTypeH      = GLES30.glGetUniformLocation( mProgramH, "vType");
+    mNameH      = GLES30.glGetUniformLocation( mProgramH, "vName");
     mUniformsH  = GLES30.glGetUniformLocation( mProgramH, "vUniforms");
     }
 
@@ -67,65 +58,24 @@ class EffectQueueVertex extends EffectQueue
     if( currTime==mTime ) return;
     if( mTime==0 ) mTime = currTime;
     long step = (currTime-mTime);
-   
+
     for(int i=0; i<mNumEffects; i++)
       {
       mCurrentDuration[i] += step;
 
-      if( mInter[0][i]!=null )
+      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )
         {
-        if( mInter[0][i].interpolateMain(mUniforms ,NUM_UNIFORMS*i, mCurrentDuration[i], step) )
-          {
-          postprocess(i);
+        for(int j=0; j<mNumListeners; j++)
+          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-          for(int j=0; j<mNumListeners; j++)
-            EffectMessageSender.newMessage( mListeners.elementAt(j),
-                                            EffectMessage.EFFECT_FINISHED,
-                                           (mID[i]<<Effect.LENGTH)+Effect.VERTEX,
-                                            mName[i],
-                                            mObjectID);
-
-          if( VertexEffect.isUnity(mName[i], mUniforms, NUM_UNIFORMS*i) )
-            {
-            remove(i);
-            i--;
-            continue;
-            }
-          else mInter[0][i] = null;
-          }
-        else
-          {
-          postprocess(i);
-          }
+        if( VertexEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+          remove(i--);
         }
-
-      if( mInter[1][i]!=null ) mInter[1][i].interpolateMain(mUniforms, NUM_UNIFORMS*i+8, mCurrentDuration[i], step);
-      if( mInter[2][i]!=null ) mInter[2][i].interpolateMain(mCache   , NUM_CACHE*i     , mCurrentDuration[i], step);
       }
-     
-    mTime = currTime;  
-    }  
-  
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  protected void moveEffect(int index)
-    {
-    mUniforms[NUM_UNIFORMS*index   ] = mUniforms[NUM_UNIFORMS*(index+1)   ];
-    mUniforms[NUM_UNIFORMS*index+ 1] = mUniforms[NUM_UNIFORMS*(index+1)+ 1];
-    mUniforms[NUM_UNIFORMS*index+ 2] = mUniforms[NUM_UNIFORMS*(index+1)+ 2];
-    mUniforms[NUM_UNIFORMS*index+ 3] = mUniforms[NUM_UNIFORMS*(index+1)+ 3];
-    mUniforms[NUM_UNIFORMS*index+ 4] = mUniforms[NUM_UNIFORMS*(index+1)+ 4];
-
-    mCache[NUM_CACHE*index  ] = mCache[NUM_CACHE*(index+1)  ];
-    mCache[NUM_CACHE*index+1] = mCache[NUM_CACHE*(index+1)+1];
-    mCache[NUM_CACHE*index+2] = mCache[NUM_CACHE*(index+1)+2];
 
-    mUniforms[NUM_UNIFORMS*index+ 8] = mUniforms[NUM_UNIFORMS*(index+1)+ 8];
-    mUniforms[NUM_UNIFORMS*index+ 9] = mUniforms[NUM_UNIFORMS*(index+1)+ 9];
-    mUniforms[NUM_UNIFORMS*index+10] = mUniforms[NUM_UNIFORMS*(index+1)+10];
-    mUniforms[NUM_UNIFORMS*index+11] = mUniforms[NUM_UNIFORMS*(index+1)+11];
+    mTime = currTime;
     }
-   
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   synchronized void send(float halfX, float halfY, float halfZ)
@@ -136,122 +86,13 @@ class EffectQueueVertex extends EffectQueue
       {
       for(int i=0; i<mNumEffects; i++)
         {
-        mUniforms[NUM_UNIFORMS*i+5] = mCache[NUM_CACHE*i  ]-halfX;
-        mUniforms[NUM_UNIFORMS*i+6] =-mCache[NUM_CACHE*i+1]+halfY;
-        mUniforms[NUM_UNIFORMS*i+7] = mCache[NUM_CACHE*i+2]-halfZ;
+        mUniforms[NUM_UNIFORMS*i+5] = mUniforms[NUM_UNIFORMS*i+5]-halfX;
+        mUniforms[NUM_UNIFORMS*i+6] =-mUniforms[NUM_UNIFORMS*i+6]+halfY;
+        mUniforms[NUM_UNIFORMS*i+7] = mUniforms[NUM_UNIFORMS*i+7]-halfZ;
         }
 
-      GLES30.glUniform1iv( mTypeH    ,                 mNumEffects, mName    ,0);
+      GLES30.glUniform1iv( mNameH    ,                 mNumEffects, mName    ,0);
       GLES30.glUniform4fv( mUniformsH,(NUM_UNIFORMS/4)*mNumEffects, mUniforms,0);
       }
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Do various post-processing on already computed effects.
-// 1) here unlike in the fragment queue, we don't have to multiply the points by ModelView matrix because that gets done in the shader.
-// 2) in case of SWIRL, switch the angles from degrees to radians
-// 3) likewise in case of WAVE and PINCH
-// 4) In case of DISTORT, invert the Y-axis
-  
-  private void postprocess(int effect)
-    {
-    if( mName[effect]==VertexEffect.SWIRL )
-      {
-      mUniforms[NUM_UNIFORMS*effect  ] = (float)(Math.PI*mUniforms[NUM_UNIFORMS*effect  ]/180);
-      }
-    if( mName[effect]==VertexEffect.PINCH )
-      {
-      mUniforms[NUM_UNIFORMS*effect+1] = (float)(Math.PI*mUniforms[NUM_UNIFORMS*effect+1]/180);
-      }
-    if( mName[effect]==VertexEffect.WAVE )
-      {
-      mUniforms[NUM_UNIFORMS*effect+2] = (float)(Math.PI*mUniforms[NUM_UNIFORMS*effect+2]/180);
-      mUniforms[NUM_UNIFORMS*effect+3] = (float)(Math.PI*mUniforms[NUM_UNIFORMS*effect+3]/180);
-      mUniforms[NUM_UNIFORMS*effect+4] = (float)(Math.PI*mUniforms[NUM_UNIFORMS*effect+4]/180);
-      }
-    if( mName[effect]==VertexEffect.DISTORT )
-      {
-      mUniforms[NUM_UNIFORMS*effect+1] =-mUniforms[NUM_UNIFORMS*effect+1];
-      }
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  synchronized long add(VertexEffect ve)
-    {
-    if( mMax[INDEX]>mNumEffects )
-      {
-      if( ve.mDynamic0 != null )
-        {
-        mInter[0][mNumEffects] = ve.mDynamic0;
-        }
-      else
-        {
-        mInter[0][mNumEffects] = null;
-
-        if( ve.mStatic0 != null )
-          {
-          Static s = ve.mStatic0;
-
-          switch( s.getDimension() )
-            {
-            case 5 : mUniforms[NUM_UNIFORMS*mNumEffects + 4] = ((Static5D)s).getV();
-            case 4 : mUniforms[NUM_UNIFORMS*mNumEffects + 3] = ((Static4D)s).getW();
-            case 3 : mUniforms[NUM_UNIFORMS*mNumEffects + 2] = ((Static3D)s).getZ();
-            case 2 : mUniforms[NUM_UNIFORMS*mNumEffects + 1] = ((Static2D)s).getY();
-            case 1 : mUniforms[NUM_UNIFORMS*mNumEffects    ] = ((Static1D)s).getX();
-            }
-          }
-        }
-
-      if( ve.mRegion!=null )
-        {
-        if( ve.mRegion instanceof Dynamic4D)
-          {
-          mInter[1][mNumEffects] = (Dynamic4D)ve.mRegion;
-          }
-        else if ( ve.mRegion instanceof Static4D)
-          {
-          Static4D tmp = (Static4D)ve.mRegion;
-
-          float z = tmp.getZ();
-
-          mUniforms[NUM_UNIFORMS*mNumEffects+ 8] = tmp.getX();
-          mUniforms[NUM_UNIFORMS*mNumEffects+ 9] =-tmp.getY();   // invert y already
-          mUniforms[NUM_UNIFORMS*mNumEffects+10] = z<=0.0f ? Float.MAX_VALUE : z;
-          mUniforms[NUM_UNIFORMS*mNumEffects+11] = tmp.getW();
-          mInter[1][mNumEffects] = null;
-          }
-        else return -1;
-        }
-      else
-        {
-        mUniforms[NUM_UNIFORMS*mNumEffects+ 8] = 0.0f;
-        mUniforms[NUM_UNIFORMS*mNumEffects+ 9] = 0.0f;
-        mUniforms[NUM_UNIFORMS*mNumEffects+10] = Float.MAX_VALUE;
-        mUniforms[NUM_UNIFORMS*mNumEffects+11] = 0.0f;
-        mInter[1][mNumEffects] = null;
-        }
-
-      if( ve.mCenter instanceof Dynamic3D)
-        {
-        mInter[2][mNumEffects] = (Dynamic3D)ve.mCenter;
-        }
-      else if( ve.mCenter instanceof Static3D)
-        {
-        mInter[2][mNumEffects] = null;
-        mCache[NUM_CACHE*mNumEffects  ] = ((Static3D)ve.mCenter).getX();
-        mCache[NUM_CACHE*mNumEffects+1] = ((Static3D)ve.mCenter).getY();
-        mCache[NUM_CACHE*mNumEffects+2] = ((Static3D)ve.mCenter).getZ();
-        }
-
-      long ret= addBase(ve);
-
-      postprocess(mNumEffects-1); //addBase just incremented mNumEffects
-
-      return ret;
-      }
-
-    return -1;
-    }
   }
diff --git a/src/main/java/org/distorted/library/message/EffectListener.java b/src/main/java/org/distorted/library/message/EffectListener.java
index dc0d4a2..fa54980 100644
--- a/src/main/java/org/distorted/library/message/EffectListener.java
+++ b/src/main/java/org/distorted/library/message/EffectListener.java
@@ -35,15 +35,13 @@ public interface EffectListener
  * Gets called when event of type 'eventType' happens to effect 'effectID'.
  * 
  * @param eventType  Type of event that happened.
- * @param effectID   ID of the effect the event happened to. This ID must have been previously returned by one
- *                   of the DistortedEffects.{deform,distort,move,...} functions.
- * @param effectName Name of the effect as defined by final constants from the 4 classes descendant from Effect.
- * @param objectID   the ID of the DistortedEffects object, as returned by {@link DistortedEffects#getID()},
+ * @param effectID   ID of the effect the event happened to, as returned by {@link org.distorted.library.effect.Effect#getID() }
+ * @param objectID   the ID of the DistortedEffects object, as returned by {@link org.distorted.library.main.DistortedEffects#getID()},
  *                   this event happened to.
  * @see EffectMessage
  */
    
-  void effectMessage(final EffectMessage eventType, final long effectID, final int effectName, final long objectID);
+  void effectMessage(final EffectMessage eventType, final long effectID, final long objectID);
   }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/res/raw/main_fragment_shader.glsl b/src/main/res/raw/main_fragment_shader.glsl
index 1ffb4cc..6d1497d 100644
--- a/src/main/res/raw/main_fragment_shader.glsl
+++ b/src/main/res/raw/main_fragment_shader.glsl
@@ -38,7 +38,7 @@ uniform sampler2D u_Texture;            // The input texture.
 
 #if NUM_FRAGMENT>0
 uniform int fNumEffects;                // total number of fragment effects
-uniform int fType[NUM_FRAGMENT];        // their types.
+uniform int fName[NUM_FRAGMENT];        // their namess.
 uniform vec4 fUniforms[2*NUM_FRAGMENT]; // i-th effect is 2 consecutive vec4's: [2*i], [2*i+1]. First vec4 is the Interpolated values,
                                         // next describes the Region, i.e. area over which the effect is active.
 
@@ -116,34 +116,34 @@ void main()
     pointDegree = max(0.0,1.0-dot(diff,diff));
 
 #ifdef CHROMA
-    if( fType[i]==CHROMA            ) chroma    (sign(pointDegree),j,pixel); else
+    if( fName[i]==CHROMA            ) chroma    (sign(pointDegree),j,pixel); else
 #endif
 #ifdef SMOOTH_CHROMA
-    if( fType[i]==SMOOTH_CHROMA     ) chroma    (     pointDegree ,j,pixel); else
+    if( fName[i]==SMOOTH_CHROMA     ) chroma    (     pointDegree ,j,pixel); else
 #endif
 #ifdef ALPHA
-    if( fType[i]==ALPHA             ) alpha     (sign(pointDegree),j,pixel); else
+    if( fName[i]==ALPHA             ) alpha     (sign(pointDegree),j,pixel); else
 #endif
 #ifdef SMOOTH_ALPHA
-    if( fType[i]==SMOOTH_ALPHA      ) alpha     (     pointDegree ,j,pixel); else
+    if( fName[i]==SMOOTH_ALPHA      ) alpha     (     pointDegree ,j,pixel); else
 #endif
 #ifdef BRIGHTNESS
-    if( fType[i]==BRIGHTNESS        ) brightness(sign(pointDegree),j,pixel); else
+    if( fName[i]==BRIGHTNESS        ) brightness(sign(pointDegree),j,pixel); else
 #endif
 #ifdef SMOOTH_BRIGHTNESS
-    if( fType[i]==SMOOTH_BRIGHTNESS ) brightness(     pointDegree ,j,pixel); else
+    if( fName[i]==SMOOTH_BRIGHTNESS ) brightness(     pointDegree ,j,pixel); else
 #endif
 #ifdef CONTRAST
-    if( fType[i]==CONTRAST          ) contrast  (sign(pointDegree),j,pixel); else
+    if( fName[i]==CONTRAST          ) contrast  (sign(pointDegree),j,pixel); else
 #endif
 #ifdef SMOOTH_CONTRAST
-    if( fType[i]==SMOOTH_CONTRAST   ) contrast  (     pointDegree ,j,pixel); else
+    if( fName[i]==SMOOTH_CONTRAST   ) contrast  (     pointDegree ,j,pixel); else
 #endif
 #ifdef SATURATION
-    if( fType[i]==SATURATION        ) saturation(sign(pointDegree),j,pixel); else
+    if( fName[i]==SATURATION        ) saturation(sign(pointDegree),j,pixel); else
 #endif
 #ifdef SMOOTH_SATURATION
-    if( fType[i]==SMOOTH_SATURATION ) saturation(     pointDegree ,j,pixel); else
+    if( fName[i]==SMOOTH_SATURATION ) saturation(     pointDegree ,j,pixel); else
 #endif
     {}
 
diff --git a/src/main/res/raw/main_vertex_shader.glsl b/src/main/res/raw/main_vertex_shader.glsl
index 9974d0e..570a3ef 100644
--- a/src/main/res/raw/main_vertex_shader.glsl
+++ b/src/main/res/raw/main_vertex_shader.glsl
@@ -45,7 +45,7 @@ uniform mat4 u_MVMatrix;             // the combined model/view matrix.
 
 #if NUM_VERTEX>0
 uniform int vNumEffects;             // total number of vertex effects
-uniform int vType[NUM_VERTEX];       // their types.
+uniform int vName[NUM_VERTEX];       // their names.
 uniform vec4 vUniforms[3*NUM_VERTEX];// i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
                                      // The first vec4 is the Interpolated values,
                                      // next is half cache half Center, the third -  the Region.
@@ -534,22 +534,22 @@ void main()
   for(int i=0; i<vNumEffects; i++)
     {
 #ifdef DISTORT
-    if( vType[i]==DISTORT) distort(j,v,n); else
+    if( vName[i]==DISTORT) distort(j,v,n); else
 #endif
 #ifdef DEFORM
-    if( vType[i]==DEFORM ) deform (j,v,n); else
+    if( vName[i]==DEFORM ) deform (j,v,n); else
 #endif
 #ifdef SINK
-    if( vType[i]==SINK   ) sink   (j,v);   else
+    if( vName[i]==SINK   ) sink   (j,v);   else
 #endif
 #ifdef PINCH
-    if( vType[i]==PINCH  ) pinch  (j,v);   else
+    if( vName[i]==PINCH  ) pinch  (j,v);   else
 #endif
 #ifdef SWIRL
-    if( vType[i]==SWIRL  ) swirl  (j,v);   else
+    if( vName[i]==SWIRL  ) swirl  (j,v);   else
 #endif
 #ifdef WAVE
-    if( vType[i]==WAVE   ) wave   (j,v,n); else
+    if( vName[i]==WAVE   ) wave   (j,v,n); else
 #endif
     {}