commit a0397f32e7fc50a45104fe3f567bb8383e7b1628
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Thu May 2 13:54:21 2019 +0100

    Make DistortedEffects oblivious of the effect types.

diff --git a/src/main/java/org/distorted/library/main/DistortedChildrenList.java b/src/main/java/org/distorted/library/main/DistortedChildrenList.java
index 20c1397..0964d19 100644
--- a/src/main/java/org/distorted/library/main/DistortedChildrenList.java
+++ b/src/main/java/org/distorted/library/main/DistortedChildrenList.java
@@ -99,12 +99,15 @@ class DistortedChildrenList implements DistortedMaster.Slave
   void addSortingByBuckets(DistortedNode newChild)
     {
     int i;
-    long bucket = newChild.getEffects().getPostprocess().getID();
+    EffectQueue queue = newChild.getEffects().getQueues()[3];
+    long bucket = queue.getID();
     boolean sameBucket = false;
 
     for(i=0; i<mNumChildren; i++)
       {
-      if( mChildren.get(i).getEffects().getPostprocess().getID() == bucket )
+      queue = mChildren.get(i).getEffects().getQueues()[3];
+
+      if( queue.getID() == bucket )
         {
         sameBucket=true;
         }
diff --git a/src/main/java/org/distorted/library/main/DistortedEffects.java b/src/main/java/org/distorted/library/main/DistortedEffects.java
index fc5b271..3556d56 100644
--- a/src/main/java/org/distorted/library/main/DistortedEffects.java
+++ b/src/main/java/org/distorted/library/main/DistortedEffects.java
@@ -131,12 +131,7 @@ public class DistortedEffects
   private static long mNextID =0;
   private long mID;
 
-  private EffectQueueMatrix mM;
-  private EffectQueueFragment mF;
-  private EffectQueueVertex mV;
-  private EffectQueuePostprocess mP;
-
-  private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;
+  private EffectQueue[] mQueues;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -154,11 +149,6 @@ public class DistortedEffects
     String enabledEffectV= VertexEffect.getGLSL();
     String enabledEffectF= FragmentEffect.getGLSL();
 
-    //android.util.Log.e("Effects", "vertHeader= "+mainVertHeader);
-    //android.util.Log.e("Effects", "fragHeader= "+mainFragHeader);
-    //android.util.Log.e("Effects", "enabledV= "+enabledEffectV);
-    //android.util.Log.e("Effects", "enabledF= "+enabledEffectF);
-
     String[] feedback = { "v_Position", "v_endPosition" };
 
     try
@@ -173,9 +163,7 @@ public class DistortedEffects
       }
 
     int mainProgramH = mMainProgram.getProgramHandle();
-    EffectQueueFragment.getUniforms(mainProgramH,0);
-    EffectQueueVertex.getUniforms(mainProgramH,0);
-    EffectQueueMatrix.getUniforms(mainProgramH,0);
+    EffectQueue.getUniforms(mainProgramH,0);
     mMainTextureH= GLES31.glGetUniformLocation( mainProgramH, "u_Texture");
 
     // BLIT PROGRAM ////////////////////////////////////
@@ -267,9 +255,7 @@ public class DistortedEffects
       }
 
     int mainOITProgramH = mMainOITProgram.getProgramHandle();
-    EffectQueueFragment.getUniforms(mainOITProgramH,1);
-    EffectQueueVertex.getUniforms(mainOITProgramH,1);
-    EffectQueueMatrix.getUniforms(mainOITProgramH,1);
+    EffectQueue.getUniforms(mainOITProgramH,1);
     mMainOITTextureH    = GLES31.glGetUniformLocation( mainOITProgramH, "u_Texture");
     mMainOITSizeH       = GLES31.glGetUniformLocation( mainOITProgramH, "u_Size");
     mMainOITNumRecordsH = GLES31.glGetUniformLocation( mainOITProgramH, "u_numRecords");
@@ -357,92 +343,23 @@ public class DistortedEffects
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void initializeEffectLists(DistortedEffects d, int flags)
+  EffectQueue[] getQueues()
     {
-    if( (flags & Distorted.CLONE_MATRIX) != 0 )
-      {
-      mM = d.mM;
-      matrixCloned = true;
-      }
-    else
-      {
-      mM = new EffectQueueMatrix(mID);
-      matrixCloned = false;
-      }
-    
-    if( (flags & Distorted.CLONE_VERTEX) != 0 )
-      {
-      mV = d.mV;
-      vertexCloned = true;
-      }
-    else
-      {
-      mV = new EffectQueueVertex(mID);
-      vertexCloned = false;
-      }
-    
-    if( (flags & Distorted.CLONE_FRAGMENT) != 0 )
-      {
-      mF = d.mF;
-      fragmentCloned = true;
-      }
-    else
-      {
-      mF = new EffectQueueFragment(mID);
-      fragmentCloned = false;
-      }
-
-    if( (flags & Distorted.CLONE_POSTPROCESS) != 0 )
-      {
-      mP = d.mP;
-      postprocessCloned = true;
-      }
-    else
-      {
-      mP = new EffectQueuePostprocess(mID);
-      postprocessCloned = false;
-      }
-    }
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  EffectQueueMatrix getMatrix()
-    {
-    return mM;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  EffectQueueVertex getVertex()
-    {
-    return mV;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  EffectQueueFragment getFragment()
-    {
-    return mF;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  EffectQueuePostprocess getPostprocess()
-    {
-    return mP;
+    return mQueues;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   void newNode(DistortedNode node)
     {
-    mP.newNode(node);
+    EffectQueue.newNode(mQueues,node);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   void removeNode(DistortedNode node)
     {
-    mP.removeNode(node);
+    EffectQueue.removeNode(mQueues,node);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -461,7 +378,7 @@ public class DistortedEffects
     GLES31.glBindBufferBase(GLES31.GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
 
     mNormalProgram.useProgram();
-    GLES31.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, mM.getMVP() , 0);
+    GLES31.glUniformMatrix4fv(mNormalMVPMatrixH, 1, false, EffectQueue.getMVP(mQueues) , 0);
     mesh.bindTransformAttribs(mNormalProgram);
     GLES31.glLineWidth(8.0f);
     GLES31.glDrawArrays(GLES31.GL_LINES, 0, 2*num);
@@ -473,11 +390,7 @@ public class DistortedEffects
     {
     float halfZ = halfW*mesh.getZFactor();
 
-    mM.compute(currTime);
-    mV.compute(currTime,halfW,halfH,halfZ);
-    mF.compute(currTime,halfW,halfH,halfZ);
-    mP.compute(currTime);
-
+    EffectQueue.compute(mQueues, currTime, halfW, halfH, halfZ );
     GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );
 
     mMainOITProgram.useProgram();
@@ -489,18 +402,13 @@ public class DistortedEffects
 
     float inflate = mesh.getInflate();
 
-    mM.send(surface,halfW,halfH,halfZ,1);
-    mV.send(inflate,1);
-    mF.send(1);
-
+    EffectQueue.send(mQueues, surface, inflate, halfW, halfH, halfZ, 1 );
     GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
 
     if( mesh.getShowNormals() )
       {
       mMainProgram.useProgram();
-      mM.send(surface,halfW,halfH,halfZ,0);
-      mV.send(inflate,0);
-      mF.send(0);
+      EffectQueue.send(mQueues, surface, inflate, halfW, halfH, halfZ, 0 );
       displayNormals(mesh);
       }
     }
@@ -511,22 +419,12 @@ public class DistortedEffects
     {
     float halfZ = halfW*mesh.getZFactor();
 
-    mM.compute(currTime);
-    mV.compute(currTime,halfW,halfH,halfZ);
-    mF.compute(currTime,halfW,halfH,halfZ);
-    mP.compute(currTime);
-
+    EffectQueue.compute(mQueues, currTime, halfW, halfH, halfZ );
     GLES31.glViewport(0, 0, surface.mWidth, surface.mHeight );
-
     mMainProgram.useProgram();
     GLES31.glUniform1i(mMainTextureH, 0);
-
     mesh.bindVertexAttribs(mMainProgram);
-
-    mM.send(surface,halfW,halfH,halfZ,0);
-    mV.send( mesh.getInflate(),0);
-    mF.send(0);
-
+    EffectQueue.send(mQueues, surface, mesh.getInflate(), halfW, halfH, halfZ, 0 );
     GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() );
 
     if( mesh.getShowNormals() ) displayNormals(mesh);
@@ -729,21 +627,6 @@ public class DistortedEffects
     GLES31.glDrawArrays(GLES31.GL_TRIANGLE_STRIP, 0, 4);
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  private void releasePriv()
-    {
-    if( !matrixCloned      ) mM.abortAll(false);
-    if( !vertexCloned      ) mV.abortAll(false);
-    if( !fragmentCloned    ) mF.abortAll(false);
-    if( !postprocessCloned ) mP.abortAll(false);
-
-    mM = null;
-    mV = null;
-    mF = null;
-    mP = null;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   static void onPause()
@@ -776,7 +659,8 @@ public class DistortedEffects
   public DistortedEffects()
     {
     mID = ++mNextID;
-    initializeEffectLists(this,0);
+    mQueues = new EffectQueue[EffectType.LENGTH];
+    EffectQueue.allocateQueues(mQueues,null,0,mID);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -792,17 +676,8 @@ public class DistortedEffects
   public DistortedEffects(DistortedEffects dc, int flags)
     {
     mID = ++mNextID;
-    initializeEffectLists(dc,flags);
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Releases all resources. After this call, the queue should not be used anymore.
- */
-  @SuppressWarnings("unused")
-  public synchronized void delete()
-    {
-    releasePriv();
+    mQueues = new EffectQueue[EffectType.LENGTH];
+    EffectQueue.allocateQueues(mQueues,dc.getQueues(),flags,mID);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -826,10 +701,10 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public void registerForMessages(EffectListener el)
     {
-    mM.registerForMessages(el);
-    mV.registerForMessages(el);
-    mF.registerForMessages(el);
-    mP.registerForMessages(el);
+    for( int i=0; i<EffectType.LENGTH; i++)
+      {
+      mQueues[i].registerForMessages(el);
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -841,10 +716,10 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public void deregisterForMessages(EffectListener el)
     {
-    mM.deregisterForMessages(el);
-    mV.deregisterForMessages(el);
-    mF.deregisterForMessages(el);
-    mP.deregisterForMessages(el);
+    for( int i=0; i<EffectType.LENGTH; i++)
+      {
+      mQueues[i].deregisterForMessages(el);
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -854,7 +729,14 @@ public class DistortedEffects
  */
   public int abortAllEffects()
     {
-    return mM.abortAll(true) + mV.abortAll(true) + mF.abortAll(true) + mP.abortAll(true);
+    int aborted = 0;
+
+    for( int i=0; i<EffectType.LENGTH; i++)
+      {
+      aborted += mQueues[i].abortAll(true);
+      }
+
+    return aborted;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -866,14 +748,8 @@ public class DistortedEffects
  */
   public int abortByType(EffectType type)
     {
-    switch(type)
-      {
-      case MATRIX     : return mM.abortAll(true);
-      case VERTEX     : return mV.abortAll(true);
-      case FRAGMENT   : return mF.abortAll(true);
-      case POSTPROCESS: return mP.abortAll(true);
-      default         : return 0;
-      }
+    int num = type.ordinal();
+    return mQueues[num].abortAll(true);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -885,14 +761,8 @@ public class DistortedEffects
  */
   public int abortById(long id)
     {
-    long type = id&EffectType.MASK;
-
-    if( type == EffectType.MATRIX.ordinal()      ) return mM.removeById(id);
-    if( type == EffectType.VERTEX.ordinal()      ) return mV.removeById(id);
-    if( type == EffectType.FRAGMENT.ordinal()    ) return mF.removeById(id);
-    if( type == EffectType.POSTPROCESS.ordinal() ) return mP.removeById(id);
-
-    return 0;
+    int num = (int)(id&EffectType.MASK);
+    return mQueues[num].removeById(id);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -904,14 +774,8 @@ public class DistortedEffects
  */
   public int abortEffect(Effect effect)
     {
-    switch(effect.getType())
-      {
-      case MATRIX     : return mM.removeEffect(effect);
-      case VERTEX     : return mV.removeEffect(effect);
-      case FRAGMENT   : return mF.removeEffect(effect);
-      case POSTPROCESS: return mP.removeEffect(effect);
-      default         : return 0;
-      }
+    int num = effect.getType().ordinal();
+    return mQueues[num].removeEffect(effect);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -923,14 +787,8 @@ public class DistortedEffects
  */
   public int abortByName(EffectName name)
     {
-    switch(name.getType())
-      {
-      case MATRIX     : return mM.removeByName(name);
-      case VERTEX     : return mV.removeByName(name);
-      case FRAGMENT   : return mF.removeByName(name);
-      case POSTPROCESS: return mP.removeByName(name);
-      default                : return 0;
-      }
+    int num = name.getType().ordinal();
+    return mQueues[num].removeByName(name);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -979,14 +837,7 @@ public class DistortedEffects
  */
   public boolean apply(Effect effect)
     {
-    switch(effect.getType())
-      {
-      case MATRIX      : return mM.add(effect);
-      case VERTEX      : return mV.add(effect);
-      case FRAGMENT    : return mF.add(effect);
-      case POSTPROCESS : return mP.add(effect);
-      }
-
-    return false;
+    int num = effect.getType().ordinal();
+    return mQueues[num].add(effect);
     }
   }
diff --git a/src/main/java/org/distorted/library/main/DistortedOutputSurface.java b/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
index a644e39..eeace94 100644
--- a/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
+++ b/src/main/java/org/distorted/library/main/DistortedOutputSurface.java
@@ -398,7 +398,7 @@ public abstract class DistortedOutputSurface extends DistortedSurface implements
     for(int i=0; i<numChildren; i++)
       {
       child = children.getChild(i);
-      currQueue = child.getEffects().getPostprocess();
+      currQueue = (EffectQueuePostprocess)child.getEffects().getQueues()[3];
       currBucket= currQueue.getID();
 
       if( currBucket==0 )
diff --git a/src/main/java/org/distorted/library/main/EffectQueue.java b/src/main/java/org/distorted/library/main/EffectQueue.java
index da072d8..759904f 100644
--- a/src/main/java/org/distorted/library/main/EffectQueue.java
+++ b/src/main/java/org/distorted/library/main/EffectQueue.java
@@ -96,6 +96,79 @@ abstract class EffectQueue implements DistortedMaster.Slave
     DistortedMaster.newSlave(this);                     // of uniforms later, on first render.
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void allocateQueues(EffectQueue[] queues, EffectQueue[] from, int flags, long id)
+    {
+    queues[0] = (flags & Distorted.CLONE_MATRIX     ) != 0 ? from[0] : new EffectQueueMatrix(id);
+    queues[1] = (flags & Distorted.CLONE_VERTEX     ) != 0 ? from[1] : new EffectQueueVertex(id);
+    queues[2] = (flags & Distorted.CLONE_FRAGMENT   ) != 0 ? from[2] : new EffectQueueFragment(id);
+    queues[3] = (flags & Distorted.CLONE_POSTPROCESS) != 0 ? from[3] : new EffectQueuePostprocess(id);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void compute(EffectQueue[] queues, long currTime, float halfW, float halfH, float halfZ )
+    {
+    ((EffectQueueMatrix     )queues[0]).compute(currTime);
+    ((EffectQueueVertex     )queues[1]).compute(currTime,halfW,halfH,halfZ);
+    ((EffectQueueFragment   )queues[2]).compute(currTime,halfW,halfH,halfZ);
+    ((EffectQueuePostprocess)queues[3]).compute(currTime);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void send(EffectQueue[] queues, DistortedOutputSurface surface, float inflate, float halfW, float halfH, float halfZ, int variant )
+    {
+    ((EffectQueueMatrix  )queues[0]).send(surface,halfW,halfH,halfZ, variant);
+    ((EffectQueueVertex  )queues[1]).send(inflate, variant);
+    ((EffectQueueFragment)queues[2]).send(variant);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static float[] getMVP(EffectQueue[] queues)
+    {
+    return ((EffectQueueMatrix  )queues[0]).getMVP();
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void newNode(EffectQueue[] queues, DistortedNode node)
+    {
+    queues[3].newNode(node);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void removeNode(EffectQueue[] queues, DistortedNode node)
+    {
+    queues[3].removeNode(node);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// queues - guaranteed to be an array of EffectType.LENGTH length.
+// Change this when creating a new ty[e of effect!
+
+  static void getUniforms(int programH, int variant)
+    {
+    EffectQueueFragment.getUniforms(programH,variant);
+    EffectQueueVertex  .getUniforms(programH,variant);
+    EffectQueueMatrix  .getUniforms(programH,variant);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Every effect queue has an ID, which should be the same iff two queues hold the same effects.
 // (this is a speedup: then both queues can be applied once, which seriously speeds up stuff -
@@ -130,7 +203,7 @@ abstract class EffectQueue implements DistortedMaster.Slave
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void newNode(DistortedNode node)
+  private void newNode(DistortedNode node)
     {
     if( mNodes==null ) mNodes = new ArrayList<>();
 
@@ -139,7 +212,7 @@ abstract class EffectQueue implements DistortedMaster.Slave
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void removeNode(DistortedNode node)
+  private void removeNode(DistortedNode node)
     {
     mNodes.remove(node);
     }
diff --git a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
index a8869c9..7f85e1d 100644
--- a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
+++ b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
@@ -170,9 +170,9 @@ class EffectQueuePostprocess extends EffectQueue
 
       mesh.bindVertexAttribs(mPreProgram);
 
-      DistortedEffects effects = node.getEffects();
-      EffectQueueMatrix matrix = effects.getMatrix();
-      EffectQueueVertex vertex = effects.getVertex();
+      EffectQueue[] queues = node.getEffects().getQueues();
+      EffectQueueMatrix matrix = (EffectQueueMatrix)queues[0];
+      EffectQueueVertex vertex = (EffectQueueVertex)queues[1];
 
       float inflate=0.0f;