Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

import java.util.ArrayList;

import java.util.HashMap;

import android.opengl.GLES20;

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * That recursively renders the set held in the Node and all its children.

  private static long mNextNodeID =0;

  private ArrayList<DistortedTree> mChildren;

  private class NodeData

    {

      numPointingNodes= 1;

    mNextNodeID = 0;

    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()

    {

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      ret.add(node.mData.ID);

      }

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void adjustNodeData(ArrayList<Long> oldList, ArrayList<Long> newList)

    {

    if( otherNodesPoint ) mData.numPointingNodes--;

    else                  mMapNodeID.remove(oldList);

    if( newData==null )

      {

      else                   mData.ID = ++mNextNodeID;  // numPointingNodes must be 1 already

        {

        if( mData.mDF==null )

      else

        {

        if( mData.mDF!=null )

          {

          mData.mDF.markForDeletion();

          mData.mDF = null;

          }

        else

          {

        }

      }

    else

      mData = newData;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////  

// this will be called on startup and every time OpenGL context has been lost

    {

    NodeData tmp;   

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Debug - print all the Node IDs

    {

    String tmp="";

    int i;

    for(i=0; i<depth; i++) tmp +="   ";

    for(i=0; i<mNumChildren[0]; i++)

      mChildren.get(i).debug(depth+1);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// Debug - print contents of the HashMap

  static void debugMap()

    {

    NodeData tmp;

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      android.util.Log.e("NODE", "key="+key+" NodeID: "+tmp.ID);

      }

    }

  void drawRecursive(long currTime, DistortedFramebuffer df)

    {

    mTexture.createTexture();

    if( mNumChildren[0]<=0 )

      {

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexture.mTextureDataH[0]);

      }

    else

      {

      mData.mDF.createFBO();

      if( mData.numRendered==0 )

        {

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mData.mDF.fboIds[0]);

        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        if( mTexture.mBitmapSet[0] )

          {

          GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexture.mTextureDataH[0]);

        synchronized(this)

          {

          for(int i=0; i<mNumChildren[0]; i++)

            {

            mChildren.get(i).drawRecursive(currTime, mData.mDF);

            }

          }

        }

      mData.numRendered++;

      mData.numRendered %= mData.numPointingNodes;

      GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, df.fboIds[0]);

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mData.mDF.texIds[0]);

      }

// PUBLIC API

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Constructs new Node of the Tree.

 *     

    mChildren = null;

    mNumChildren = new int[1];

    mNumChildren[0] = 0;

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

    }

///////////////////////////////////////////////////////////////////////////////////////////////////  

/**

 * Copy-constructs new Node of the Tree from another Node.

 *     

 *        For example flags = CLONE_BITMAP | CLONE_CHILDREN.

 */

    if( (flags & Distorted.CLONE_CHILDREN) != 0 )

      mChildren = node.mChildren;

      mNumChildren = node.mNumChildren;

      }

    else

      {

      mChildren = null;

      mNumChildren = new int[1];

      mNumChildren[0] = 0;

      }

    ArrayList<Long> list = generateIDList();

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 * @param node The new Node to add.

 */

    ArrayList<Long> prev = generateIDList(); 

    node.mParent = this;

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 */

    ArrayList<Long> prev = generateIDList(); 

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 * @param node The Node to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      if( mChildren.remove(node) )

        {

        node.mParent = null;  

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 */

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

        ArrayList<Long> prev = generateIDList();   

        node.mParent = null;  

        mChildren.remove(i);

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes all children Nodes.

 */

  public synchronized void detachAll()

    {

    for(int i=0; i<mNumChildren[0]; i++)

      {

      mChildren.get(i).mParent = null;

      }

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      mNumChildren[0] = 0;

      mChildren.clear();

      RecomputeNodeID(prev);

      }

    }

/**

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Returns the DistortedTexture object that's in the Node.

 *

 * @return The DistortedTexture contained in the Node.

 */

  public DistortedTexture getTexture()

    {

    return mTexture;

  }