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

« Previous | Next »

Revision c204c69d

Added by Leszek Koltunski about 7 years ago

ID c204c69db2ef3787663ea13a08c92a52ba5049d6
Parent f8377ef8
Child af27df87

New, cleaner way to create/destroy DistortedSurfaces.

Serious regression in StarWars (crashes!). Looks like the Node's internal FBO is being deleted and not re-created in time.

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Class which represents a Node in a Tree of (InputSurface,Mesh,Effects) triplets.
+     *
      * <p>
      * Having organized such sets into a Tree, we can then render any Node to any OutputSurface.
      * That recursively renders the set held in the Node and all its children.
      * <p>
      * The class takes special care to only render identical sub-trees once. Each Node holds a reference
      * to sub-class 'NodeData'. Two identical sub-trees attached at different points of the main tree
      * will point to the same NodeData; only the first of this is rendered (when mData.numRendered==0).
      */
     public class DistortedNode
     public class DistortedNode implements DistortedAttacheable
+      {
       private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();
       private static long mNextNodeID =0;
-...
       private DistortedInputSurface mSurface;
       private NodeData mData;
       private DistortedNode mParent;
       private ArrayList<DistortedNode> mChildren;
       private int[] mNumChildren;  // ==mChildren.length(), but we only create mChildren if the first one gets added
-...
           numPointingNodes= 1;
           numRendered     = 0;
           mFBO            = null;
           android.util.Log.e("DistortedNode", "new NodeData");
+          }
+        }
-...
         mMapNodeID.clear();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // tree isomorphism
       private void RecomputeNodeID(ArrayList<Long> prev)
+        {
         ArrayList<Long> curr = generateIDList();
         if( mParent==null )
+          {
           adjustNodeData(prev,curr);
+          }
         else
+          {
           ArrayList<Long> parentPrev = mParent.generateIDList();
           adjustNodeData(prev,curr);
           mParent.RecomputeNodeID(parentPrev);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private ArrayList<Long> generateIDList()
-...
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void adjustNodeData(ArrayList<Long> oldList, ArrayList<Long> newList)
+        {
         boolean otherNodesPoint = (mData.numPointingNodes>1);
         if( otherNodesPoint ) mData.numPointingNodes--;
         else                  mMapNodeID.remove(oldList);
         NodeData newData = mMapNodeID.get(newList);
         if( newData==null )
+          {
           if( otherNodesPoint )  mData = new NodeData(++mNextNodeID);
           else                   mData.ID = ++mNextNodeID;  // numPointingNodes must be 1 already
           if( newList.size()>1 )
+            {
             if( mData.mFBO ==null )
+              {
               android.util.Log.e("DistortedNode", "creating a new FBO");
               mData.mFBO = new DistortedFramebuffer(mSurface.getWidth(), mSurface.getHeight());
+              }
+            }
           else
+            {
             if( mData.mFBO !=null )
+              {
               android.util.Log.e("DistortedNode", "marking FBO for deletion and setting it to NULL");
               mData.mFBO.markForDeletion();
               mData.mFBO = null;
+              }
             else
+              {
               android.util.Log.e("DistortedNode", "adjustNodeData: impossible situation??");
+              }
+            }
           mMapNodeID.put(newList, mData);
+          }
         else
+          {
           newData.numPointingNodes++;
           mData = newData;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // this will be called on startup and every time OpenGL context has been lost
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Debug - print all the Node IDs
     /*
       void debug(int depth)
+        {
         String tmp="";
         int i;
         for(i=0; i<depth; i++) tmp +="   ";
         tmp += (mData.ID+" (nodes: "+mData.numPointingNodes+")");
         tmp += ("NodeID="+mData.ID+" (nodes pointing: "+mData.numPointingNodes+" surfaceID="+mSurface.getID()+")");
         android.util.Log.e("NODE", tmp);
-...
         for(ArrayList<Long> key: mMapNodeID.keySet())
+          {
           tmp = mMapNodeID.get(key);
           android.util.Log.e("NODE", "NodeID: "+tmp.ID+" <-- "+key);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void treeIsomorphism()
+        {
         android.util.Log.e("NODE", "begin treeIso for Node Surface ID="+mSurface.getID());
         debug(0);
         debugMap();
         android.util.Log.e("NODE", "begin treeIso for Node Surface ID="+mSurface.getID());
         ArrayList<Long> oldList = generateIDList();
         for(int i=0; i<mNumChildren[0]; i++)
+          {
           mChildren.get(i).treeIsomorphism();
+          }
         ArrayList<Long> newList = generateIDList();
         NodeData newData = mMapNodeID.get(newList);
         if( newData==null )
+          {
           android.util.Log.d("NODE", "  inserted newData to map, newList="+newList);
           newData = new NodeData(++mNextNodeID);
           mMapNodeID.put(newList,newData);
           debugMap();
+          }
         else if( newData.ID != mData.ID )
+          {
           newData.numPointingNodes++;
+          }
         if( newData.ID != mData.ID )
+          {
           boolean fboUsed = false;
           if( mNumChildren[0]>0 && newData.mFBO==null )
+            {
             if( mData.mFBO!=null )
+              {
               newData.mFBO = mData.mFBO;
               fboUsed = true;
+              }
             else
+              {
               newData.mFBO = new DistortedFramebuffer(mSurface.getWidth(),mSurface.getHeight());
+              }
+            }
           if( mNumChildren[0]==0 && newData.mFBO!=null )
+            {
             newData.mFBO.markForDeletion();
             newData.mFBO = null;
+            }
           if( --mData.numPointingNodes==0 )
+            {
             android.util.Log.d("NODE", "  removed oldData to map, oldList="+oldList);
           android.util.Log.e("NODE", "key="+key+" NodeID: "+tmp.ID);
             mMapNodeID.remove(oldList);
             debugMap();
             if( !fboUsed && mData.mFBO!=null )
+              {
               mData.mFBO.markForDeletion();
               mData.mFBO = null;
+              }
+            }
           mData = newData;
+          }
         android.util.Log.e("NODE", "end treeIso for Node SurfaceID="+mSurface.getID()+" newList="+newList);
         debug(0);
         debugMap();
         android.util.Log.e("NODE", "end treeIso for Node SurfaceID="+mSurface.getID()+" newList="+newList);
+        }
     */
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void drawRecursive(long currTime, DistortedOutputSurface surface)
-...
         mSurface       = surface;
         mEffects       = effects;
         mMesh          = mesh;
         mParent        = null;
         mChildren      = null;
         mNumChildren   = new int[1];
         mNumChildren[0]= 0;
-...
      */
       public DistortedNode(DistortedNode node, int flags)
+        {
         mParent = null;
         mEffects= new DistortedEffects(node.mEffects,flags);
         mMesh = node.mMesh;
-...
+          }
         if( (flags & Distorted.CLONE_CHILDREN) != 0 )
+          {
           if( node.mChildren==null )     // do NOT copy over the NULL!
+            {
             node.mChildren = new ArrayList<>(2);
+            }
           mChildren = node.mChildren;
           mNumChildren = node.mNumChildren;
+          }
-...
           mMapNodeID.put(list, mData);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Adds a new child to the last position in the list of our Node's children.
+     *
      * <p>
      * We cannot do this mid-render - actual attachment will be done just before the next render, by the
      * DistortedAttachDeamon (by calling attachNow())
+     *
      * @param node The new Node to add.
      */
       public synchronized void attach(DistortedNode node)
       public void attach(DistortedNode node)
+        {
         ArrayList<Long> prev = generateIDList();
         if( mChildren==null ) mChildren = new ArrayList<>(2);
         android.util.Log.e("DistortedNode", "ATTACH1");
         node.mParent = this;
         mChildren.add(node);
         mNumChildren[0]++;
         RecomputeNodeID(prev);
         DistortedAttachDaemon.attach(this,node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Adds a new child to the last position in the list of our Node's children.
+     *
      * <p>
      * We cannot do this mid-render - actual attachment will be done just before the next render, by the
      * DistortedAttachDeamon (by calling attachNow())
+     *
      * @param surface InputSurface to initialize our child Node with.
      * @param effects DistortedEffects to initialize our child Node with.
      * @param mesh MeshObject to initialize our child Node with.
      * @return the newly constructed child Node, or null if we couldn't allocate resources.
      */
       public synchronized DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)
       public DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)
+        {
         ArrayList<Long> prev = generateIDList();
         android.util.Log.e("DistortedNode", "ATTACH2");
         DistortedNode node = new DistortedNode(surface,effects,mesh);
         DistortedAttachDaemon.attach(this,node);
         return node;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedAttacheable interface, which should really be a class that we extend here instead but
      * Java has no multiple inheritance.
+     *
      * @param node The new Node to add.
      */
       public void attachNow(DistortedNode node)
+        {
         if( mChildren==null ) mChildren = new ArrayList<>(2);
         DistortedNode node = new DistortedNode(surface,effects,mesh);
         node.mParent = this;
         mChildren.add(node);
         mNumChildren[0]++;
         RecomputeNodeID(prev);
         return node;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Removes the first occurrence of a specified child from the list of children of our Node.
+     *
      * <p>
      * We cannot do this mid-render - actual detachment will be done just before the next render, by the
      * DistortedAttachDeamon (by calling detachNow())
+     *
      * @param node The Node to remove.
      * @return <code>true</code> if the child was successfully removed.
      */
       public synchronized boolean detach(DistortedNode node)
       public void detach(DistortedNode node)
+        {
         if( mNumChildren[0]>0 )
+          {
           ArrayList<Long> prev = generateIDList();
           if( mChildren.remove(node) )
+            {
     android.util.Log.e("DistortedNode", "DETACH1");
             node.mParent = null;
             mNumChildren[0]--;
             RecomputeNodeID(prev);
             return true;
+            }
+          }
         return false;
         DistortedAttachDaemon.detach(this,node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * <p>
      * A bit questionable method as there can be many different Nodes attached as children, some
      * of them having the same Effects but - for instance - different Mesh. Use with care.
      * <p>
      * We cannot do this mid-render - actual detachment will be done just before the next render, by the
      * DistortedAttachDeamon (by calling detachNow())
+     *
      * @param effects DistortedEffects to remove.
      * @return <code>true</code> if the child was successfully removed.
      */
       public synchronized boolean detach(DistortedEffects effects)
       public void detach(DistortedEffects effects)
+        {
         long id = effects.getID();
         DistortedNode node;
-...
           if( node.mEffects.getID()==id )
+            {
     android.util.Log.e("DistortedNode", "DETACH2");
             ArrayList<Long> prev = generateIDList();
             node.mParent = null;
             mChildren.remove(i);
             mNumChildren[0]--;
             RecomputeNodeID(prev);
             return true;
             DistortedAttachDaemon.detach(this,node);
             break;
+            }
+          }
         return false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Removes all children Nodes.
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedAttacheable interface, which should really be a class that we extend here instead but
      * Java has no multiple inheritance.
+     *
      * @param node The Node to remove.
      */
       public synchronized void detachAll()
       public void detachNow(DistortedNode node)
+        {
         for(int i=0; i<mNumChildren[0]; i++)
         if( mNumChildren[0]>0 && mChildren.remove(node) )
+          {
           mChildren.get(i).mParent = null;
           mNumChildren[0]--;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Removes all children Nodes.
      * <p>
      * We cannot do this mid-render - actual detachment will be done just before the next render, by the
      * DistortedAttachDeamon (by calling detachAllNow())
      */
       public void detachAll()
+        {
         DistortedAttachDaemon.detachAll(this);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedAttacheable interface, which should really be a class that we extend here instead but
      * Java has no multiple inheritance.
      */
       public void detachAllNow()
+        {
         if( mNumChildren[0]>0 )
+          {
           ArrayList<Long> prev = generateIDList();
           mNumChildren[0] = 0;
           mChildren.clear();
           RecomputeNodeID(prev);
+          }
+        }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision c204c69d

Added by Leszek Koltunski about 7 years ago