commit 26a4e5f698842ca81b08530e2654114326c4966f
Author: leszek <leszek@koltunski.pl>
Date:   Thu Jun 15 01:14:19 2017 +0100

    Reorganize the way we add and remove all Effects (do it through DistortedMaster and is POSTPROCES - adjust Bucket and SORT Nodes).
    
    Buggy: removing effects does not work.

diff --git a/src/main/java/org/distorted/library/main/Distorted.java b/src/main/java/org/distorted/library/main/Distorted.java
index d1118de..8f296b7 100644
--- a/src/main/java/org/distorted/library/main/Distorted.java
+++ b/src/main/java/org/distorted/library/main/Distorted.java
@@ -24,6 +24,7 @@ import android.content.Context;
 import android.content.pm.ConfigurationInfo;
 import android.content.res.Resources;
 
+import org.distorted.library.effect.Effect;
 import org.distorted.library.program.*;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -149,6 +150,7 @@ public class Distorted
     DistortedEffects.onDestroy();
     DistortedMaster.onDestroy();
     EffectQueue.onDestroy();
+    Effect.onDestroy();
     EffectMessageSender.stopSending();
 
     mInitialized = false;
diff --git a/src/main/java/org/distorted/library/main/DistortedEffects.java b/src/main/java/org/distorted/library/main/DistortedEffects.java
index 5079d26..058f2aa 100644
--- a/src/main/java/org/distorted/library/main/DistortedEffects.java
+++ b/src/main/java/org/distorted/library/main/DistortedEffects.java
@@ -284,7 +284,7 @@ public class DistortedEffects implements DistortedSlave
 
   long getBucket()
     {
-    return mP.getBucket();
+    return mP.getID();
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -301,6 +301,16 @@ public class DistortedEffects implements DistortedSlave
     return mP.getHalo();
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void newNode(DistortedNode node)
+    {
+    mM.newNode(node);
+    mF.newNode(node);
+    mV.newNode(node);
+    mP.newNode(node);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /**
  * This is not really part of the public API. Has to be public only because it is a part of the
@@ -454,6 +464,7 @@ public class DistortedEffects implements DistortedSlave
  */
   public DistortedEffects()
     {
+    android.util.Log.e("distEffects", "constr1");
     mID = ++mNextID;
     initializeEffectLists(this,0);
     }
@@ -470,6 +481,7 @@ public class DistortedEffects implements DistortedSlave
  */
   public DistortedEffects(DistortedEffects dc, int flags)
     {
+    android.util.Log.e("distEffects", "constr2");
     mID = ++mNextID;
     initializeEffectLists(dc,flags);
     }
@@ -505,9 +517,9 @@ public class DistortedEffects implements DistortedSlave
   @SuppressWarnings("unused")
   public void registerForMessages(EffectListener el)
     {
+    mM.registerForMessages(el);
     mV.registerForMessages(el);
     mF.registerForMessages(el);
-    mM.registerForMessages(el);
     mP.registerForMessages(el);
     }
 
@@ -520,9 +532,9 @@ public class DistortedEffects implements DistortedSlave
   @SuppressWarnings("unused")
   public void deregisterForMessages(EffectListener el)
     {
+    mM.deregisterForMessages(el);
     mV.deregisterForMessages(el);
     mF.deregisterForMessages(el);
-    mM.deregisterForMessages(el);
     mP.deregisterForMessages(el);
     }
 
@@ -690,9 +702,9 @@ public class DistortedEffects implements DistortedSlave
     {
     switch(effect.getType())
       {
+      case MATRIX      : return mM.add(effect);
       case VERTEX      : return mV.add(effect);
       case FRAGMENT    : return mF.add(effect);
-      case MATRIX      : return mM.add(effect);
       case POSTPROCESS : return mP.add(effect);
       }
 
diff --git a/src/main/java/org/distorted/library/main/DistortedNode.java b/src/main/java/org/distorted/library/main/DistortedNode.java
index aa656eb..bb5ba4e 100644
--- a/src/main/java/org/distorted/library/main/DistortedNode.java
+++ b/src/main/java/org/distorted/library/main/DistortedNode.java
@@ -335,6 +335,23 @@ public class DistortedNode implements DistortedSlave
     mParent = null;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void sort()
+    {
+    if( mParent!=null )
+      {
+      mParent.mChildren.remove(this);
+      DistortedMaster.addSorted(mParent.mChildren,this);
+      }
+    else if( mSurfaceParent!=null )
+      {
+      ArrayList<DistortedNode> children = mSurfaceParent.getChildren();
+      children.remove(this);
+      DistortedMaster.addSorted(children,this);
+      }
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -376,6 +393,8 @@ public class DistortedNode implements DistortedSlave
       mData = new NodeData(++mNextNodeID,list);
       mMapNodeID.put(list, mData);
       }
+
+    mEffects.newNode(this);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////  
@@ -456,6 +475,8 @@ public class DistortedNode implements DistortedSlave
       mData = new NodeData(++mNextNodeID,list);
       mMapNodeID.put(list, mData);
       }
+
+    mEffects.newNode(this);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/main/DistortedOutputSurface.java b/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
index c1b143c..94edd0b 100644
--- a/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
+++ b/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
@@ -317,9 +317,9 @@ sLast = sCurr;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void newJob(int t, DistortedNode n)
+  ArrayList<DistortedNode> getChildren()
     {
-    mJobs.add(new Job(t,n));
+    return mChildren;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -341,7 +341,8 @@ sLast = sCurr;
  */
   public void setDebug(int bitmask)
     {
-    mDebugLevel = bitmask;
+    if( this instanceof DistortedScreen )
+      mDebugLevel = bitmask;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -356,9 +357,7 @@ sLast = sCurr;
  */
   public int render(long time)
     {
-    boolean showDebug = ( mDebugLevel!=0 && this instanceof DistortedScreen );
-
-    if( showDebug ) prepareDebug(time);
+    if( mDebugLevel!=0 ) prepareDebug(time);
 
     // change tree topology (attach and detach children)
 /*
@@ -404,7 +403,7 @@ sLast = sCurr;
     setAsOutput(time);
     numRenders += renderChildren(time,mNumChildren,mChildren);
 
-    if( showDebug ) renderDebug(time);
+    if( mDebugLevel != 0 ) renderDebug(time);
 
     return numRenders;
     }
diff --git a/src/main/java/org/distorted/library/main/DistortedScreen.java b/src/main/java/org/distorted/library/main/DistortedScreen.java
index 551cc2a..303c36d 100644
--- a/src/main/java/org/distorted/library/main/DistortedScreen.java
+++ b/src/main/java/org/distorted/library/main/DistortedScreen.java
@@ -55,6 +55,7 @@ public class DistortedScreen extends DistortedOutputSurface
   private long[] durations;
   private int currDuration;
   private static MatrixEffectMove mMoveEffect = new MatrixEffectMove( new Static3D(5,5,0) );
+  private boolean mInitialized;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // here we don't manage underlying OpenGL assets ourselves
@@ -63,10 +64,40 @@ public class DistortedScreen extends DistortedOutputSurface
   void delete()   {}
   void recreate() {}
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void initialize()
+    {
+    fpsW = 120;
+    fpsH =  70;
+
+    fpsBitmap = Bitmap.createBitmap(fpsW,fpsH, Bitmap.Config.ARGB_8888);
+    fpsMesh = new MeshFlat(1,1);
+    fpsTexture = new DistortedTexture(fpsW,fpsH);
+    fpsTexture.setTexture(fpsBitmap);
+    fpsCanvas = new Canvas(fpsBitmap);
+    fpsEffects = new DistortedEffects();
+    fpsEffects.apply(mMoveEffect);
+
+    mPaint = new Paint();
+    mPaint.setAntiAlias(true);
+    mPaint.setTextAlign(Paint.Align.CENTER);
+    mPaint.setTextSize(0.7f*fpsH);
+
+    durations = new long[NUM_FRAMES+1];
+    currDuration = 0;
+
+    for(int i=0; i<NUM_FRAMES+1; i++) durations[i]=16;  // Assume FPS will be
+    durations[NUM_FRAMES] = NUM_FRAMES*16;              // close to 1000/16 ~ 60
+    mInitialized=true;
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   void prepareDebug(long time)
     {
+    if( !mInitialized ) initialize();
+
     if( lastTime==0 ) lastTime = time;
 
     currDuration++;
@@ -122,27 +153,6 @@ public class DistortedScreen extends DistortedOutputSurface
       view.setEGLContextClientVersion((configurationInfo.reqGlEsVersion >> 16) >= 3 ? 3 : 2);
       }
 
-    /////// DEBUGGING ONLY //////////////
-    fpsW = 120;
-    fpsH =  70;
-
-    fpsBitmap = Bitmap.createBitmap(fpsW,fpsH, Bitmap.Config.ARGB_8888);
-    fpsMesh = new MeshFlat(1,1);
-    fpsTexture = new DistortedTexture(fpsW,fpsH);
-    fpsTexture.setTexture(fpsBitmap);
-    fpsCanvas = new Canvas(fpsBitmap);
-    fpsEffects = new DistortedEffects();
-    fpsEffects.apply(mMoveEffect);
-
-    mPaint = new Paint();
-    mPaint.setAntiAlias(true);
-    mPaint.setTextAlign(Paint.Align.CENTER);
-    mPaint.setTextSize(0.7f*fpsH);
-
-    durations = new long[NUM_FRAMES+1];
-    currDuration = 0;
-
-    for(int i=0; i<NUM_FRAMES+1; i++) durations[i]=16;  // Assume FPS will be
-    durations[NUM_FRAMES] = NUM_FRAMES*16;              // close to 1000/16 ~ 60
+    mInitialized = false;
     }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueue.java b/src/main/java/org/distorted/library/main/EffectQueue.java
index 992ca7b..117ff38 100644
--- a/src/main/java/org/distorted/library/main/EffectQueue.java
+++ b/src/main/java/org/distorted/library/main/EffectQueue.java
@@ -25,27 +25,52 @@ import org.distorted.library.effect.EffectType;
 import org.distorted.library.message.EffectListener;
 import org.distorted.library.message.EffectMessage;
 
-import java.util.Vector;
+import java.util.ArrayList;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-abstract class EffectQueue
+abstract class EffectQueue implements DistortedSlave
   {
-  protected byte mNumEffects;
+  private static final int ATTACH = 0;
+  private static final int DETACH = 1;
+  private static final int DETALL = 2;
+
+  protected int mNumEffects;
   protected float[] mUniforms;
   protected long[] mCurrentDuration;
   protected Effect[] mEffects;
   protected int[] mName;
   protected long mTime=0;
   protected static int[] mMax = new int[EffectType.LENGTH];
-  protected Vector<EffectListener> mListeners =null;
+  protected ArrayList<EffectListener> mListeners =null;
   protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
   protected long mDistortedEffectsID;
 
+  private ArrayList<DistortedNode> mNodes = null;
+  private long mID;
+  private int mNumEffectsToBe; // this will be more than mNumEffects if doWork hasn't really added them yet
   private static boolean mCreated;
   private int mIndex;
   private int mNumUniforms;
 
+  private class Job
+    {
+    int type;
+    int index;
+    boolean notify;
+    Effect effect;
+
+    Job(int t, int i, boolean n, Effect e)
+      {
+      type  = t;
+      index = i;
+      notify= n;
+      effect= e;
+      }
+    }
+
+  private ArrayList<Job> mJobs = new ArrayList<>();
+
   static
     {
     onDestroy();
@@ -55,7 +80,9 @@ abstract class EffectQueue
    
   EffectQueue(long id, int numUniforms, int index)
     {
+    mID                 = 0;
     mNumEffects         = 0;
+    mNumEffectsToBe     = 0;
     mDistortedEffectsID = id;
     mIndex              = index;
     mNumUniforms        = numUniforms;
@@ -73,6 +100,24 @@ abstract class EffectQueue
     mCreated = true;  
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// TODO: introduce a Map to return an ID dependant on all Effects in the Queue.
+// For now this is good enough.
+
+  private void regenerateID()
+    {
+    mID = mNumEffects>0 ? mEffects[0].getID() : 0;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void newNode(DistortedNode node)
+    {
+    if( mNodes==null ) mNodes = new ArrayList<>();
+
+    mNodes.add(node);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   @SuppressWarnings("unused")
@@ -82,18 +127,19 @@ abstract class EffectQueue
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// Only max Byte.MAX_VALUE concurrent effects per DistortedEffects object.
-// If you want more, change type of the mNumEffects, mIDIndex and mFreeIndexes variables to shorts.
-// (although probably this many uniforms will not fit in the shaders anyway!)
+
+  long getID()
+    {
+    return mID;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
   static boolean setMax(int index, int m)
     {
     if( (!mCreated && !Distorted.isInitialized()) || m<=mMax[index] )
       {
-      if( m<0              ) m = 0;
-      else if( m>Byte.MAX_VALUE ) m = Byte.MAX_VALUE;
-
-      mMax[index] = m;
+      mMax[index] = m<0 ? 0:m;
       return true;
       }
 
@@ -111,7 +157,7 @@ abstract class EffectQueue
 
   void registerForMessages(EffectListener el)
     {
-    if( mListeners==null ) mListeners = new Vector<>(2,2);
+    if( mListeners==null ) mListeners = new ArrayList<>();
 
     if( !mListeners.contains(el) )
       {
@@ -139,60 +185,82 @@ abstract class EffectQueue
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+// this assumes 0<=effect<mNumEffects
 
-  synchronized int removeByName(EffectName name)
+  protected void remove(int effect)
     {
-    int ret = 0;
+    mNumEffects--;
+
+    long removedID = mEffects[effect].getID();
+
+    for(int j=effect; j<mNumEffects; j++ )
+      {
+      mEffects[j]         = mEffects[j+1];
+      mCurrentDuration[j] = mCurrentDuration[j+1];
+      mName[j]            = mName[j+1];
+
+      for(int k=0; k<mNumUniforms; k++)
+        mUniforms[mNumUniforms*j+k] = mUniforms[mNumUniforms*(j+1)+k];
+      }
+
+    mEffects[mNumEffects] = null;
+
+    for(int i=0; i<mNumListeners; i++)
+      EffectMessageSender.newMessage( mListeners.get(i), EffectMessage.EFFECT_REMOVED, removedID, mDistortedEffectsID);
+    }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  synchronized int removeByName(EffectName name)
+    {
     for(int i=0; i<mNumEffects; i++)
       {
       if( mEffects[i].getName() == name )
         {
-        remove(i);
-        i--;
-        ret++;
+        mJobs.add(new Job(DETACH,i,true,null));
+        DistortedMaster.newSlave(this);
+        mNumEffectsToBe--;
+        return 1;
         }
       }
 
-    return ret;
+    return 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   synchronized int removeById(long id)
     {
-    int ret = 0;
-
     for(int i=0; i<mNumEffects; i++)
       {
       if( mEffects[i].getID() == id )
         {
-        remove(i);
-        i--;
-        ret++;
+        mJobs.add(new Job(DETACH,i,true,null));
+        DistortedMaster.newSlave(this);
+        mNumEffectsToBe--;
+        return 1;
         }
       }
 
-    return ret;
+    return 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   synchronized int removeEffect(Effect effect)
     {
-    int ret = 0;
-
     for(int i=0; i<mNumEffects; i++)
       {
       if( mEffects[i]==effect )
         {
-        remove(i);
-        i--;
-        ret++;
+        mJobs.add(new Job(DETACH,i,true,null));
+        DistortedMaster.newSlave(this);
+        mNumEffectsToBe--;
+        return 1;
         }
       }
    
-    return ret;
+    return 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -201,62 +269,88 @@ abstract class EffectQueue
 
   synchronized int abortAll(boolean notify)
     {
-    int ret = mNumEffects;
+    mJobs.add(new Job(DETALL,0,notify,null));
+    DistortedMaster.newSlave(this);
+    mNumEffectsToBe = 0;
+    return mNumEffects;
+    }
 
-    for(int i=0; i<ret; i++ )
+///////////////////////////////////////////////////////////////////////////////////////////////////
+  
+  boolean add(Effect effect)
+    {
+    if( mMax[mIndex]>mNumEffectsToBe )
       {
-      if( notify )
-        {
-        for(int j=0; j<mNumListeners; j++)
-          EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_REMOVED, mEffects[i].getID(), mDistortedEffectsID);
-        }
+      //android.util.Log.e("queue", "scheduling future add of "+effect.getName().name()+" to "+mNumEffectsToBe+" id="+effect.getID());
+      //android.util.Log.e("queue", "queue id="+mDistortedEffectsID);
 
-      mEffects[i] = null;
+      mJobs.add(new Job(ATTACH,mNumEffectsToBe,false,effect));
+      DistortedMaster.newSlave(this);
+      mNumEffectsToBe++;
+      return true;
       }
 
-    mNumEffects= 0;
-
-    return ret;
+    return false;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// this assumes 0<=effect<mNumEffects
-  
-  protected void remove(int effect)
+/**
+ * This is not really part of the public API. Has to be public only because it is a part of the
+ * DistortedSlave interface, which should really be a class that we extend here instead but
+ * Java has no multiple inheritance.
+ *
+ * @y.exclude
+ */
+  public void doWork()
     {
-    mNumEffects--;     
+    int num = mJobs.size();
+    Job job;
 
-    long removedID = mEffects[effect].getID();
-
-    for(int j=effect; j<mNumEffects; j++ ) 
+    for(int i=0; i<num; i++)
       {
-      mEffects[j]         = mEffects[j+1];
-      mCurrentDuration[j] = mCurrentDuration[j+1];
-      mName[j]            = mName[j+1];
+      job = mJobs.remove(0);
 
-      for(int k=0; k<mNumUniforms; k++)
-        mUniforms[mNumUniforms*j+k] = mUniforms[mNumUniforms*(j+1)+k];
+      switch(job.type)
+        {
+        case ATTACH: android.util.Log.e("queue", "DistortedEffects ID: "+mDistortedEffectsID+" bank:"+job.index+
+                                        " attaching effectID="+job.effect.getID()+" ("+job.effect.getName().name()+")");
+
+                     mCurrentDuration[job.index] = 0;
+                     mEffects[job.index] = job.effect;
+                     mName[job.index] = job.effect.getName().ordinal();
+                     mNumEffects++;
+                     break;
+        case DETACH: remove(job.index);
+                     break;
+        case DETALL: for(int j=0; j<mNumEffects; j++ )
+                       {
+                       if( job.notify )
+                         {
+                         for(int k=0; k<mNumListeners; k++)
+                           EffectMessageSender.newMessage( mListeners.get(k), EffectMessage.EFFECT_REMOVED, mEffects[j].getID(), mDistortedEffectsID);
+                         }
+
+                       mEffects[j] = null;
+                       }
+
+                     mNumEffects= 0;
+                     break;
+        }
       }
-   
-    mEffects[mNumEffects] = null;
 
-    for(int i=0; i<mNumListeners; i++) 
-      EffectMessageSender.newMessage( mListeners.elementAt(i), EffectMessage.EFFECT_REMOVED, removedID, mDistortedEffectsID);
-    }
-  
-///////////////////////////////////////////////////////////////////////////////////////////////////
-  
-  boolean add(Effect effect)
-    {
-    if( mMax[mIndex]>mNumEffects )
+    if( num>0 )
       {
-      mCurrentDuration[mNumEffects] = 0;
-      mEffects[mNumEffects] = effect;
-      mName[mNumEffects] = effect.getName().ordinal();
-      mNumEffects++;
-      return true;
-      }
+      regenerateID();
 
-    return false;
+      if( mIndex==EffectType.POSTPROCESS.ordinal() )
+        {
+        int numNodes = (mNodes==null ? 0: mNodes.size());
+
+        for(int i=0; i<numNodes; i++)
+          {
+          mNodes.get(i).sort();
+          }
+        }
+      }
     }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueueFragment.java b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
index f8fb229..74b57a7 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueFragment.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
@@ -66,7 +66,7 @@ class EffectQueueFragment extends EffectQueue
       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, mEffects[i].getID(), mDistortedEffectsID);
+          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
 
         if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           {
diff --git a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
index 873330d..5d04257 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
@@ -299,7 +299,7 @@ class EffectQueueMatrix extends EffectQueue
       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, mEffects[i].getID(), mDistortedEffectsID);
+          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
 
         if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           remove(i--);
diff --git a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
index 86fe7ab..fdcda91 100644
--- a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
+++ b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
@@ -187,7 +187,7 @@ class EffectQueuePostprocess extends EffectQueue
       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, mEffects[i].getID(), mDistortedEffectsID);
+          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
 
         if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           {
@@ -250,13 +250,6 @@ class EffectQueuePostprocess extends EffectQueue
       }
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  long getBucket()
-    {
-    return mNumEffects>0 ? mEffects[0].getID() : 0;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   int getHalo()
diff --git a/src/main/java/org/distorted/library/main/EffectQueueVertex.java b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
index 19504d4..39ca632 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueVertex.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
@@ -66,7 +66,7 @@ class EffectQueueVertex extends EffectQueue
       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, mEffects[i].getID(), mDistortedEffectsID);
+          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);
 
         if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           {