commit be60d4ff6cda88b6829d0258b2bc70a8e2b4018f
Author: leszek <leszek@koltunski.pl>
Date:   Sun Apr 16 22:23:32 2017 +0100

    Children now properly sorted into Postprocessing Buckets.

diff --git a/src/main/java/org/distorted/library/DistortedMaster.java b/src/main/java/org/distorted/library/DistortedMaster.java
index a337ead..a8bb231 100644
--- a/src/main/java/org/distorted/library/DistortedMaster.java
+++ b/src/main/java/org/distorted/library/DistortedMaster.java
@@ -75,6 +75,32 @@ class DistortedMaster
     if( !found ) mSlaves.add(s);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  static void addSorted(ArrayList<DistortedNode> mChildren, DistortedNode newChild)
+    {
+    DistortedNode child;
+    DistortedEffectsPostprocess dep;
+    int i,num = mChildren.size();
+    long bucket, newBucket;
+
+    dep = newChild.getEffectsPostprocess();
+    newBucket = dep==null ? 0 : dep.getBucket();
+
+    for(i=0; i<num; i++)
+      {
+      child = mChildren.get(i);
+      dep   = child.getEffectsPostprocess();
+      bucket= dep==null ? 0 : dep.getBucket();
+
+      if( bucket>newBucket ) break;
+      }
+
+    mChildren.add(i,newChild);
+
+    //android.util.Log.e("newChild", "newBucket="+newBucket+" new child at "+i+" total num ="+num);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   static void onDestroy()
diff --git a/src/main/java/org/distorted/library/DistortedNode.java b/src/main/java/org/distorted/library/DistortedNode.java
index eff618a..da837c0 100644
--- a/src/main/java/org/distorted/library/DistortedNode.java
+++ b/src/main/java/org/distorted/library/DistortedNode.java
@@ -63,6 +63,7 @@ public class DistortedNode implements DistortedSlave
   private static long mNextNodeID =0;
 
   private DistortedNode mParent;
+  private DistortedOutputSurface mSurfaceParent;
   private MeshObject mMesh;
   private DistortedEffects mEffects;
   private DistortedEffectsPostprocess mPostprocess;
@@ -261,6 +262,28 @@ public class DistortedNode implements DistortedSlave
     return numRenders;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void newJob(int t, DistortedNode n, DistortedEffectsPostprocess d)
+    {
+    mJobs.add(new Job(t,n,d));
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void setPost(DistortedEffectsPostprocess dep)
+    {
+    mPostprocess = dep;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void setSurfaceParent(DistortedOutputSurface dep)
+    {
+    mSurfaceParent = dep;
+    mParent = null;
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -282,6 +305,7 @@ public class DistortedNode implements DistortedSlave
     mNumChildren   = new int[1];
     mNumChildren[0]= 0;
     mParent        = null;
+    mSurfaceParent = null;
 
     ArrayList<Long> list = new ArrayList<>();
     list.add(mSurface.getID());
@@ -312,11 +336,12 @@ public class DistortedNode implements DistortedSlave
  */
   public DistortedNode(DistortedNode node, int flags)
     {
-    mEffects     = new DistortedEffects(node.mEffects,flags);
-    mPostprocess = null;
-    mMesh        = node.mMesh;
-    mState       = new DistortedRenderState();
-    mParent      = null;
+    mEffects      = new DistortedEffects(node.mEffects,flags);
+    mPostprocess  = null;
+    mMesh         = node.mMesh;
+    mState        = new DistortedRenderState();
+    mParent       = null;
+    mSurfaceParent= null;
 
     if( (flags & Distorted.CLONE_SURFACE) != 0 )
       {
@@ -497,7 +522,6 @@ public class DistortedNode implements DistortedSlave
     Job job;
 
     int numChanges=0;
-    int numSorts  =0;
 
     for(int i=0; i<num; i++)
       {
@@ -508,13 +532,15 @@ public class DistortedNode implements DistortedSlave
         case ATTACH: numChanges++;
                      if( mChildren==null ) mChildren = new ArrayList<>(2);
                      job.node.mParent = this;
-                     mChildren.add(job.node);
+                     job.node.mSurfaceParent = null;
+                     DistortedMaster.addSorted(mChildren,job.node);
                      mNumChildren[0]++;
                      break;
         case DETACH: numChanges++;
                      if( mNumChildren[0]>0 && mChildren.remove(job.node) )
                        {
                        job.node.mParent = null;
+                       job.node.mSurfaceParent = null;
                        mNumChildren[0]--;
                        }
                      break;
@@ -527,26 +553,20 @@ public class DistortedNode implements DistortedSlave
                          {
                          tmp = mChildren.remove(j);
                          tmp.mParent = null;
+                         tmp.mSurfaceParent = null;
                          }
 
                        mNumChildren[0] = 0;
                        }
                      break;
-        case SORT  : numSorts++;
-                     // TODO: sort
+        case SORT  : job.node.mPostprocess = job.dep;
+                     mChildren.remove(job.node);
+                     DistortedMaster.addSorted(mChildren,job.node);
                      break;
         }
       }
 
-    if( numChanges>0 )
-      {
-      adjustIsomorphism();
-
-      if( numSorts==0 )
-        {
-        // TODO: sort
-        }
-      }
+    if( numChanges>0 ) adjustIsomorphism();
     }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /**
@@ -561,9 +581,20 @@ public class DistortedNode implements DistortedSlave
  */
   public void setPostprocessEffects(DistortedEffectsPostprocess dep)
     {
-    mPostprocess = dep;
-
-    // TODO: rearrange all the siblings so that all are sorted by the DistortedEffectsPostprocess' ID.
+    if( mParent!=null )
+      {
+      mParent.newJob(SORT, this, dep);
+      DistortedMaster.newSlave(mParent);
+      }
+    else if( mSurfaceParent!=null )
+      {
+      mSurfaceParent.newJob(SORT, this, dep);
+      DistortedMaster.newSlave(mSurfaceParent);
+      }
+    else
+      {
+      mPostprocess = dep;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/library/DistortedOutputSurface.java b/src/main/java/org/distorted/library/DistortedOutputSurface.java
index 072059a..f9e1e2b 100644
--- a/src/main/java/org/distorted/library/DistortedOutputSurface.java
+++ b/src/main/java/org/distorted/library/DistortedOutputSurface.java
@@ -39,11 +39,13 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
     {
     int type;
     DistortedNode node;
+    DistortedEffectsPostprocess dep;
 
-    Job(int t, DistortedNode n)
+    Job(int t, DistortedNode n, DistortedEffectsPostprocess d)
       {
       type = t;
       node = n;
+      dep  = d;
       }
     }
 
@@ -63,7 +65,9 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
 
   private float mClearR, mClearG, mClearB, mClearA;
   private float mClearDepth;
-
+/*
+private String sNew="", sOld="";
+*/
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   DistortedOutputSurface(int width, int height, int createColor, int createDepth, int fbo, int type)
@@ -96,7 +100,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void createProjection()
+  private void createProjection()
     {
     if( mWidth>0 && mHeight>1 )
       {
@@ -145,13 +149,17 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
     DistortedNode child;
     DistortedEffectsPostprocess lastP=null, currP;
     long lastB=0, currB;
-
+/*
+sNew = "";
+*/
     for(int i=0; i<num; i++)
       {
       child = children.get(i);
       currP = child.getEffectsPostprocess();
       currB = currP==null ? 0 : currP.getBucket();
-
+/*
+sNew += currB;
+*/
       if( lastB!=currB && lastB!=0 )
         {
         numRenders += lastP.postprocess(time,this);
@@ -179,10 +187,23 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
       lastP = currP;
       lastB = currB;
       }
-
+/*
+if( !sNew.equals(sOld) )
+  {
+  sOld = sNew;
+  android.util.Log.e("surface", "Surface"+getID()+": "+sOld);
+  }
+*/
     return numRenders;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void newJob(int t, DistortedNode n, DistortedEffectsPostprocess d)
+    {
+    mJobs.add(new Job(t,n,d));
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -399,7 +420,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
  */
   public void attach(DistortedNode node)
     {
-    mJobs.add(new Job(ATTACH,node));
+    mJobs.add(new Job(ATTACH,node,null));
     DistortedMaster.newSlave(this);
     }
 
@@ -418,7 +439,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
   public DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)
     {
     DistortedNode node = new DistortedNode(surface,effects,mesh);
-    mJobs.add(new Job(ATTACH,node));
+    mJobs.add(new Job(ATTACH,node,null));
     DistortedMaster.newSlave(this);
     return node;
     }
@@ -448,7 +469,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
       if( node.getEffects().getID()==id )
         {
         detached = true;
-        mJobs.add(new Job(DETACH,node));
+        mJobs.add(new Job(DETACH,node,null));
         DistortedMaster.newSlave(this);
         break;
         }
@@ -485,7 +506,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
  */
   public void detach(DistortedNode node)
     {
-    mJobs.add(new Job(DETACH,node));
+    mJobs.add(new Job(DETACH,node,null));
     DistortedMaster.newSlave(this);
     }
 
@@ -498,7 +519,7 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
  */
   public void detachAll()
     {
-    mJobs.add(new Job(DETALL,null));
+    mJobs.add(new Job(DETALL,null,null));
     DistortedMaster.newSlave(this);
     }
 
@@ -515,42 +536,41 @@ abstract class DistortedOutputSurface extends DistortedSurface implements Distor
     int num = mJobs.size();
     Job job;
 
-    int numChanges=0;
-    int numSorts  =0;
-
     for(int i=0; i<num; i++)
       {
       job = mJobs.remove(0);
 
       switch(job.type)
         {
-        case ATTACH: numChanges++;
-                     if( mChildren==null ) mChildren = new ArrayList<>(2);
-                     mChildren.add(job.node);
+        case ATTACH: if( mChildren==null ) mChildren = new ArrayList<>(2);
+                     job.node.setSurfaceParent(this);
+                     DistortedMaster.addSorted(mChildren,job.node);
                      mNumChildren++;
                      break;
-        case DETACH: numChanges++;
-                     if( mNumChildren>0 && mChildren.remove(job.node) )
+        case DETACH: if( mNumChildren>0 && mChildren.remove(job.node) )
                        {
+                       job.node.setSurfaceParent(null);
                        mNumChildren--;
                        }
                      break;
-        case DETALL: numChanges++;
-                     if( mNumChildren>0 )
+        case DETALL: if( mNumChildren>0 )
                        {
+                       DistortedNode tmp;
+
+                       for(int j=mNumChildren-1; j>=0; j--)
+                         {
+                         tmp = mChildren.remove(j);
+                         tmp.setSurfaceParent(null);
+                         }
+
                        mNumChildren = 0;
-                       mChildren.clear();
                        }
                      break;
-        case SORT  : numSorts++;
-                     // TODO: sort
+        case SORT  : job.node.setPost(job.dep);
+                     mChildren.remove(job.node);
+                     DistortedMaster.addSorted(mChildren,job.node);
                      break;
         }
       }
-
-    if( numChanges>0 && numSorts==0 )
-      {
-      // TODO: sort
-      }
     }
 }