Distorted Android

package org.distorted.library;

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>

 * will point to the same NodeData; only the first of this is rendered (mData.numRender!).

 */

public class DistortedNode implements DistortedAttacheable

  {

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

  private DistortedNode mParent;

  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

    long ID;

    int numPointingNodes;

    int numRender;

    ArrayList<Long> key;

    DistortedFramebuffer mFBO;

    NodeData(long id, ArrayList<Long> k)

      {

      ID              = id;

      key             = k;

      numPointingNodes= 1;

      numRender       =-1;

      mFBO            = null;

      }

    }

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

  static synchronized void onDestroy()

    {

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

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

    ret.add( mSurface.getID() );

    DistortedNode node;

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

  @SuppressWarnings("unused")

  void debug(int depth)

    tmp += ("NodeID="+mData.ID+" nodes pointing: "+mData.numPointingNodes+" surfaceID="+

            mSurface.getID()+" FBO="+(mData.mFBO==null ? "null":mData.mFBO.getID()))+

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

  @SuppressWarnings("unused")

  static void debugMap()

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

// tree isomorphism algorithm

  private void adjustIsomorphism()

    {

    if( newData!=null )

      {

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

      mMapNodeID.put(newList,newData);

    boolean deleteOldFBO = false;

    if( --mData.numPointingNodes==0 )

      {

      mMapNodeID.remove(mData.key);

    if( deleteOldFBO && createNewFBO )

      //android.util.Log.d("NODE", "copying over FBOs "+mData.mFBO.getID() );

      }

      //android.util.Log.d("NODE", "deleting old FBO "+mData.mFBO.getID() );

      mData.mFBO = null;

      //android.util.Log.d("NODE", "creating new FBO "+newData.mFBO.getID() );

      }

    mData = newData;

    if( mParent!=null ) mParent.adjustIsomorphism();

    }

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

// return the total number of render calls issued

  int drawRecursive(int renderNum, long currTime, DistortedOutputSurface surface)

    {

    int ret = 0;

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

    if( mNumChildren[0]>0 && mData.numRender!=renderNum )

      {

      mData.numRender = renderNum;

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

      if( mSurface.setAsInput() )

        }

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

      }

    DistortedInputSurface input = mNumChildren[0]==0 ? mSurface : mData.mFBO;

    if( input.setAsInput() )

    }

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

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

    mParent        = null;

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

    list.add(mSurface.getID());

    list.add(-mEffects.getID());

    mData = mMapNodeID.get(list);

      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;

      }

      int w = node.mSurface.getWidth();

      if( node.mSurface instanceof DistortedTexture )

        {

        mSurface = new DistortedTexture(w,h, DistortedSurface.TYPE_TREE);

        }

      else if( node.mSurface instanceof DistortedFramebuffer )

        {

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

        mSurface = new DistortedFramebuffer(hasDepth,DistortedSurface.TYPE_TREE,w,h);

        }

      }

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

      {

      if( node.mChildren==null )     // do NOT copy over the NULL!

      mChildren = node.mChildren;

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

      mMapNodeID.put(list, mData);

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

 * <p>

 * @param node The new Node to add.

  public void attach(DistortedNode node)

    {

    DistortedAttachDaemon.attach(this,node);

    }

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

 * <p>

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

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

 * @y.exclude

 * @param node The new Node to add.

    if( mChildren==null ) mChildren = new ArrayList<>(2);

    node.mParent = this;

    mChildren.add(node);

    adjustIsomorphism();

    }

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

 * <p>

 * @param node The Node to remove.

  public void detach(DistortedNode node)

    {

    DistortedAttachDaemon.detach(this,node);

    }

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

 * <p>

 * <p>

 *

 * @param effects DistortedEffects to remove.

 */

  public void detach(DistortedEffects effects)

    {

    long id = effects.getID();

    DistortedNode node;

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

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

        {

        DistortedAttachDaemon.detach(this,node);

        }

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

 * This is not really part of the public API. Has to be public only because it is a part of the

 * @y.exclude

 * @param node The Node to remove.

 */

  public void detachNow(DistortedNode node)

    {

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

      {

      node.mParent = null;

      mNumChildren[0]--;

      adjustIsomorphism();

      }

    }

 *

 */

    if( mNumChildren[0]>0 )

      DistortedNode tmp;

      for(int i=mNumChildren[0]-1; i>=0; i--)

        {

        tmp = mChildren.remove(i);

        }

      }

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

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

    }

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

  }