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/>.                            //

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

package org.distorted.library;

import java.util.ArrayList;

import java.util.HashMap;

import android.opengl.GLES30;

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

/**

 * 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 implements DistortedAttacheable

  {

  private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();

  private static long mNextNodeID =0;

  private MeshObject mMesh;

  private DistortedEffects mEffects;

  private DistortedInputSurface mSurface;

  private NodeData mData;

  private ArrayList<DistortedNode> mChildren;

  private int[] mNumChildren;  // ==mChildren.length(), but we only create mChildren if the first one gets added

  private class NodeData

    {

    long ID;

    int numPointingNodes;

    int numRendered;

    ArrayList<Long> key;

    DistortedFramebuffer mFBO;

    NodeData(long id, ArrayList<Long> k)

      {

      ID              = id;

      key             = k;

      numPointingNodes= 1;

      numRendered     = 0;

      mFBO            = null;

      }

    }

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

  static synchronized void onDestroy()

    {

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

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

  private ArrayList<Long> generateIDList()

    {

    ArrayList<Long> ret = new ArrayList<>();

    ret.add( mSurface.getID() );

    DistortedNode node;

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

      {

      node = mChildren.get(i);

      ret.add(node.mData.ID);

      }

    return ret;

    }

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

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

  static void reset()

    {

    NodeData tmp;   

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

      {

      tmp = mMapNodeID.get(key);

      if( tmp.mFBO != null ) tmp.numRendered = 0;

      }

    }

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

// Debug - print all the Node IDs

  @SuppressWarnings("unused")

  void debug(int depth)

    {

    String tmp="";

    int i;

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

    tmp += ("NodeID="+mData.ID+" (nodes pointing: "+mData.numPointingNodes+" surfaceID="+mSurface.getID()+")");

    android.util.Log.e("NODE", tmp);

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

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

    }

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

// Debug - print contents of the HashMap

  @SuppressWarnings("unused")

  static void debugMap()

    {

    NodeData tmp;

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

      {

      tmp = mMapNodeID.get(key);

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

      }

    }

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

  void treeIsomorphism()

    {

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

      {

      mChildren.get(i).treeIsomorphism();

      }

    ArrayList<Long> newList = generateIDList();

    NodeData newData = mMapNodeID.get(newList);

    if( newData==null )

      {

      newData = new NodeData(++mNextNodeID,newList);

      mMapNodeID.put(newList,newData);

      }

    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 )

          {

          android.util.Log.d("NODE", "copying over FBO of node surfaceID="+mSurface.getID());

          newData.mFBO = mData.mFBO;

          fboUsed = true;

          }

        else

          {

          android.util.Log.d("NODE", "creating new FBO of node surfaceID="+mSurface.getID());

          newData.mFBO = new DistortedFramebuffer(mSurface.getWidth(),mSurface.getHeight());

          }

        }

      if( mNumChildren[0]==0 && newData.mFBO!=null )

        {

        android.util.Log.d("NODE", "deleting FBO of newData node!!");

        newData.mFBO.markForDeletion();

        newData.mFBO = null;

        }

      if( --mData.numPointingNodes==0 )

        {

        mMapNodeID.remove(mData.key);

        if( !fboUsed && mData.mFBO!=null )

          {

          android.util.Log.d("NODE", "deleting FBO of node surfaceID="+mSurface.getID());

          mData.mFBO.markForDeletion();

          mData.mFBO = null;

          }

        }

      mData = newData;

      }

    }

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

  void drawRecursive(long currTime, DistortedOutputSurface surface)

    {

    float halfX = mSurface.getWidth()/2.0f;

    float halfY = mSurface.getHeight()/2.0f;

    if( mNumChildren[0]<=0 )

      {

      mSurface.setAsInput();

      }

    else

      {

      if( mData.numRendered==0 )

        {

        mData.mFBO.setAsOutput();

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

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

        if( mSurface.setAsInput() )

          DistortedEffects.drawNoEffectsPriv(halfX, halfY, mMesh, mData.mFBO );

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

          {

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

          }

        }

      mData.numRendered++;

      mData.numRendered %= mData.numPointingNodes;

      mData.mFBO.setAsInput();

      }

    mEffects.drawPriv(halfX, halfY, mMesh, surface, currTime);

    }

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

// PUBLIC API

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

/**

 * Constructs new Node.

 *     

 * @param surface InputSurface to put into the new Node.

 * @param effects DistortedEffects to put into the new Node.

 * @param mesh MeshObject to put into the new Node.

 */

  public DistortedNode(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    {

    mSurface       = surface;

    mEffects       = effects;

    mMesh          = mesh;

    mChildren      = null;

    mNumChildren   = new int[1];

    mNumChildren[0]= 0;

    ArrayList<Long> list = new ArrayList<>();

    list.add(mSurface.getID());

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID,list);

      mMapNodeID.put(list, mData);

      }

    }

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

/**

 * Copy-constructs new Node from another Node.

 *     

 * @param node The DistortedNode to copy data from.

 * @param flags bit field composed of a subset of the following:

 *        {@link Distorted#CLONE_SURFACE},  {@link Distorted#CLONE_MATRIX}, {@link Distorted#CLONE_VERTEX},

 *        {@link Distorted#CLONE_FRAGMENT} and {@link Distorted#CLONE_CHILDREN}.

 *        For example flags = CLONE_SURFACE | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

    mEffects= new DistortedEffects(node.mEffects,flags);

    mMesh = node.mMesh;

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

      {

      mSurface = node.mSurface;

      }

    else

      {

      int w = node.mSurface.getWidth();

      int h = node.mSurface.getHeight();

      if( node.mSurface instanceof DistortedTexture )

        {

        mSurface = new DistortedTexture(w,h);

        }

      else if( node.mSurface instanceof DistortedFramebuffer )

        {

        boolean hasDepth = ((DistortedFramebuffer) node.mSurface).hasDepth();

        mSurface = new DistortedFramebuffer(w,h,hasDepth);

        }

      }

    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;

      }

    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,list);

      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 void attach(DistortedNode node)

    {

    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 DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    {

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

    mChildren.add(node);

    mNumChildren[0]++;

    }

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

/**

 * 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.

 */

  public void detach(DistortedNode node)

    {

    DistortedAttachDaemon.detach(this,node);

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our 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.

 */

  public void detach(DistortedEffects effects)

    {

    long id = effects.getID();

    DistortedNode node;

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

      {

      node = mChildren.get(i);

      if( node.mEffects.getID()==id )

        {

        DistortedAttachDaemon.detach(this,node);

        break;

        }

      }

    }

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

/**

 * 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 void detachNow(DistortedNode node)

    {

    if( mNumChildren[0]>0 && mChildren.remove(node) )

      {

      mNumChildren[0]--;

      if( mNumChildren[0]==0 && mData.mFBO!=null )

        {

        mData.mFBO.markForDeletion();

        mData.mFBO = null;

        }

      }

    }

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

/**

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

      {

      mNumChildren[0] = 0;

      mChildren.clear();

      if( mData.mFBO!=null )

        {

        mData.mFBO.markForDeletion();

        mData.mFBO = null;

        }

      }

    }

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

/**

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

 * 

 * @return The DistortedEffects contained in the Node.

 */

  public DistortedEffects getEffects()

    {

    return mEffects;

    }

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

/**

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

 *

 * @return The DistortedInputSurface contained in the Node.

 */

  public DistortedInputSurface getSurface()

    {

    return mSurface;

    }

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

/**

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

 *

 * @return The DistortedFramebuffer contained in the Node.

 */

  public DistortedFramebuffer getFramebuffer()

    {

    return mData.mFBO;

    }

  }