/src/main/java/org/distorted/library/main/DistortedOutputSurface.java - Diff - Distorted Android

« Previous | Next »

Revision 11845a9e

Added by Leszek Koltunski about 5 years ago

ID 11845a9ed9e2d7122cd74182385d628d9f6d4a78
Parent 6bce98fc
Child 84d51487

Carve the 'children list' from DOutputSurface and DNode into a separate class of its own, DistortedChildrenList.

     import org.distorted.library.effect.EffectQuality;
     import org.distorted.library.mesh.MeshBase;
     import java.util.ArrayList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API.
+     *
      * @y.exclude
      */
     public abstract class DistortedOutputSurface extends DistortedSurface implements DistortedMaster.Slave
     public abstract class DistortedOutputSurface extends DistortedSurface implements DistortedChildrenList.Parent
+    {
     /**
      * Do not create DEPTH or STENCIL attachment
      */
       public static final int NO_DEPTH_NO_STENCIL = 0;
     /**
      * Create DEPTH, but not STENCIL
      */
       public static final int DEPTH_NO_STENCIL    = 1;
     /**
      * Create both DEPTH and STENCIL
      */
       public static final int BOTH_DEPTH_STENCIL  = 2;
       private static final int ATTACH = 0;
       private static final int DETACH = 1;
       private static final int DETALL = 2;
       private static final int SORT   = 3;
       private ArrayList<DistortedNode> mChildren;
       private int mNumChildren;   // ==mChildren.length(), but we only create mChildren if the first one gets added
       private boolean mRenderWayOIT;
       private class Job
+        {
         int type;
         DistortedNode node;
         Job(int t, DistortedNode n)
+          {
           type = t;
           node = n;
+          }
+        }
       private ArrayList<Job> mJobs = new ArrayList<>();
       // Global buffers used for postprocessing.
       private static DistortedFramebuffer[] mBuffer=null;
       float mFOV;
       float mDistance, mNear;
       float mFOV, mDistance, mNear;
       float[] mProjectionMatrix;
       int mDepthStencilCreated;
       int mDepthStencil;
       int[] mDepthStencilH;
       int[] mFBOH;
       private long[] mTime;
       private float mClearR, mClearG, mClearB, mClearA;
       private float mClearDepth;
       private int mClearStencil;
       private int mClear;
       float mMipmap;
       int mRealWidth;   // the Surface can be backed up with a texture that is
-...
       int mCurrFBO;     // internal current FBO (see Distorted.FBO_QUEUE_SIZE)
       private static DistortedFramebuffer[] mBuffer=null; // Global buffers used for postprocessing.
       private long[] mTime;
       private float mClearR, mClearG, mClearB, mClearA, mClearDepth;
       private int mClear, mClearStencil;
       private boolean mRenderWayOIT;
       private DistortedChildrenList mChildren;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       DistortedOutputSurface(int width, int height, int createColor, int numfbos, int numcolors, int depthStencil, int fbo, int type)
-...
         mMipmap = 1.0f;
         mChildren = new DistortedChildrenList(this);
         createProjection();
+        }
-...
     // to a whole buffer (lastQueue.postprocess) and merge it (this.oitBuild or blitWithDepth - depending
     // on the type of rendering)
       int renderChildren(long time, int numChildren, ArrayList<DistortedNode> children, int fbo, boolean oit)
       int renderChildren(long time, int numChildren, DistortedChildrenList children, int fbo, boolean oit)
+        {
         int quality=0, numRenders=0, bucketChange=0;
         DistortedNode child;
-...
         for(int i=0; i<numChildren; i++)
+          {
           child = children.get(i);
           child = children.getChild(i);
           currQueue = child.getPostprocessQueue();
           currBucket= currQueue.getID();
-...
+                }
               else
+                {
                 for(int j=bucketChange; j<i; j++) numRenders += lastQueue.preprocess( mBuffer[quality],children.get(j) );
                 for(int j=bucketChange; j<i; j++) numRenders += lastQueue.preprocess( mBuffer[quality],children.getChild(j) );
                 numRenders += lastQueue.postprocess(mBuffer[quality]);
                 if( oit )
-...
             if( i==numChildren-1 )
+              {
               for(int j=bucketChange; j<numChildren; j++) numRenders += currQueue.preprocess( mBuffer[quality],children.get(j) );
               for(int j=bucketChange; j<numChildren; j++) numRenders += currQueue.preprocess( mBuffer[quality],children.getChild(j) );
               numRenders += currQueue.postprocess(mBuffer[quality]);
               if( oit )
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       ArrayList<DistortedNode> getChildren()
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedChildrenList.Parent interface.
+     *
      * @y.exclude
      */
       public DistortedChildrenList getChildren()
+        {
         return mChildren;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedChildrenList.Parent interface.
+     *
      * @y.exclude
      */
       public void adjustIsomorphism()
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Not part of the Public API.
-...
      */
       public int render(long time, int fbo)
+        {
         // change tree topology (attach and detach children)
     /*
         boolean changed1 =
     */
         DistortedMaster.toDo();
     /*
         if( changed1 )
+          {
           for(int i=0; i<mNumChildren; i++)
+            {
             mChildren.get(i).debug(0);
+            }
           DistortedNode.debugMap();
+          }
     */
         // create and delete all underlying OpenGL resources
         // Watch out: FIRST change topology, only then deal
         // with OpenGL resources. That's because changing Tree
         // can result in additional Framebuffers that would need
         // to be created immediately, before the calls to drawRecursive()
     /*
         boolean changed2 =
     */
         toDo();
     /*
         if( changed2 )
+          {
           DistortedObject.debugLists();
+          }
     */
         // mark OpenGL state as unknown
         DistortedRenderState.reset();
         int numRenders=0;
         int numRenders=0, numChildren = mChildren.getNumChildren();
         for(int i=0; i<mNumChildren; i++)
         for(int i=0; i<numChildren; i++)
+          {
           numRenders += mChildren.get(i).renderRecursive(time);
           numRenders += mChildren.getChild(i).renderRecursive(time);
+          }
         numRenders += renderChildren(time,mNumChildren,mChildren,fbo, mRenderWayOIT);
         numRenders += renderChildren(time,numChildren,mChildren,fbo, mRenderWayOIT);
         return numRenders;
+        }
-...
      */
       public void attach(DistortedNode node)
+        {
         mJobs.add(new Job(ATTACH,node));
         DistortedMaster.newSlave(this);
         mChildren.attach(node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public DistortedNode attach(DistortedSurface surface, DistortedEffects effects, MeshBase mesh)
+        {
         DistortedNode node = new DistortedNode(surface,effects,mesh);
         mJobs.add(new Job(ATTACH,node));
         DistortedMaster.newSlave(this);
         return node;
         return mChildren.attach(surface,effects,mesh);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public void detach(DistortedEffects effects)
+        {
         long id = effects.getID();
         DistortedNode node;
         boolean detached = false;
         for(int i=0; i<mNumChildren; i++)
+          {
           node = mChildren.get(i);
           if( node.getEffects().getID()==id )
+            {
             detached = true;
             mJobs.add(new Job(DETACH,node));
             DistortedMaster.newSlave(this);
             break;
+            }
+          }
         if( !detached )
+          {
           // if we failed to detach any, it still might be the case that
           // there's an ATTACH job that we need to cancel.
           int num = mJobs.size();
           Job job;
           for(int i=0; i<num; i++)
+            {
             job = mJobs.get(i);
             if( job.type==ATTACH && job.node.getEffects()==effects )
+              {
               mJobs.remove(i);
               break;
+              }
+            }
+          }
         mChildren.detach(effects);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public void detach(DistortedNode node)
+        {
         mJobs.add(new Job(DETACH,node));
         DistortedMaster.newSlave(this);
         mChildren.detach(node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public void detachAll()
+        {
         mJobs.add(new Job(DETALL,null));
         DistortedMaster.newSlave(this);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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()
+        {
         int num = mJobs.size();
         if( num>0 )
+          {
           Job job;
           for(int i=0; i<num; i++)
+            {
             job = mJobs.remove(0);
             switch(job.type)
+              {
               case ATTACH: if( mChildren==null ) mChildren = new ArrayList<>(2);
                            job.node.setSurfaceParent(this);
                            DistortedMaster.addSortingByBuckets(mChildren,job.node);
                            mNumChildren++;
                            break;
               case DETACH: if( mNumChildren>0 && mChildren.remove(job.node) )
+                             {
                              job.node.setSurfaceParent(null);
                              mNumChildren--;
+                             }
                            break;
               case DETALL: if( mNumChildren>0 )
+                             {
                              DistortedNode tmp;
                              for(int j=mNumChildren-1; j>=0; j--)
+                               {
                                tmp = mChildren.remove(j);
                                tmp.setSurfaceParent(null);
+                               }
                              mNumChildren = 0;
+                             }
                            break;
               case SORT  : mChildren.remove(job.node);
                            DistortedMaster.addSortingByBuckets(mChildren,job.node);
                            break;
+              }
+            }
+          }
         mChildren.detachAll();
+        }
+    }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 11845a9e

Added by Leszek Koltunski about 5 years ago