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.GLES20;

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

/**

 * Class which represents a Node in a Tree of DistortedObjects.

 *  

 * Having organized a set of DistortedObjects into a Tree, we can then render any Node to any Framebuffer.

 * That recursively renders the Object held in the Node and all its children, along with whatever effects

 * each one of them has. 

 */

public class DistortedNode 

  {

  private static final int TEXTURE_FAILED_TO_CREATE = -1;   

  private static final int TEXTURE_NOT_CREATED_YET  = -2;   

  private DistortedObject mObject;

  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

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

  private static long mNextNodeID =0;

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

  private class NodeData

    {

    long ID;  

    int numPointingNodes;

    int mFramebufferID;

    int mTextureID;

    DistortedProjection mProjection;

    boolean mRendered;

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

   public NodeData(long id)

     {

     ID = id;

     numPointingNodes= 1;

     mFramebufferID = 0;

     mTextureID = TEXTURE_NOT_CREATED_YET;

     mProjection = null;

     mRendered = false;

     }

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

    boolean createFBO()

      {  

      int[] textureIds = new int[1];

      GLES20.glGenTextures(1, textureIds, 0);

      mTextureID = textureIds[0];

      int[] mFBORenderToTexture = new int[1];

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureID);

      GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);

      GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);

      GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);

      GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);

      GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, mProjection.width, mProjection.height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);

      GLES20.glGenFramebuffers(1, mFBORenderToTexture, 0);

      GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFBORenderToTexture[0]);

      GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTextureID, 0);

      int status = GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER);

      if(status != GLES20.GL_FRAMEBUFFER_COMPLETE)

        {

        android.util.Log.e("Node", "failed to create framebuffer, error="+status);  

        GLES20.glDeleteTextures(1, textureIds, 0);

        GLES20.glDeleteFramebuffers(1, mFBORenderToTexture, 0);

        mFramebufferID = 0;

        mTextureID = TEXTURE_FAILED_TO_CREATE;

        return false;

        }

      mFramebufferID = mFBORenderToTexture[0];

      return true;

      }

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

    void deleteFBO()

      {

      int[] textureIds = new int[1];

      int[] mFBORenderToTexture = new int[1];

      textureIds[0] = mTextureID;

      mFBORenderToTexture[0] = mFramebufferID;

      GLES20.glDeleteTextures(1, textureIds, 0);

      GLES20.glDeleteFramebuffers(1, mFBORenderToTexture, 0);

      mFramebufferID = 0;

      mTextureID = TEXTURE_NOT_CREATED_YET;

      }

   }

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

  static void release()

    {

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

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

  private void markRecursive()

    {

    mData.mRendered = false;

    synchronized(this)

      {

      for(int i=0; i<mNumChildren[0]; i++) mChildren.get(i).markRecursive();

      }

    }

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

  private void drawRecursive(long currTime, DistortedProjection dp, int mFBO)

    {

    if( mNumChildren[0]<=0 )

      {

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

      if( mData.mProjection!=null )

        {

        mData.deleteFBO();

        mData.mProjection = null;

        }

      }

    else

      {

      if( mData.mRendered==false )

        {

        mData.mRendered = true;

        if( mData.mTextureID==TEXTURE_NOT_CREATED_YET ) mData.createFBO();

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mData.mFramebufferID);

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

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

        if( mObject.mBitmapSet[0] )

          {

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

          mObject.drawNoEffectsPriv(mData.mProjection);

          }

        synchronized(this)

          {

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

            {

            mChildren.get(i).drawRecursive(currTime, mData.mProjection, mData.mFramebufferID);

            }

          }

        }

      GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFBO);

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mData.mTextureID);   // this is safe because we must have called createFBO() above before.     

      }

    mObject.drawPriv(currTime, dp);

    }

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

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

    {

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

    ret.add( mNumChildren[0]>0 ? mObject.getBitmapID() : mObject.getID() );

    DistortedNode node;

    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( mData.numPointingNodes>1 ) mData.numPointingNodes--;

    else                           mMapNodeID.remove(oldList);  

    NodeData newData = mMapNodeID.get(newList);

    if( newData==null )

      {

      mData.ID = ++mNextNodeID;  

      mData.numPointingNodes = 1;

      if( newList.size()>1 && mData.mProjection==null )

        {     

        mData.mProjection = new DistortedProjection(true);

        mData.mProjection.onSurfaceChanged(mObject.getWidth(), mObject.getHeight());

        mData.mFramebufferID = 0;

        mData.mTextureID = TEXTURE_NOT_CREATED_YET;

        }

      mMapNodeID.put(newList, mData);

      }

    else

      {  

      newData.numPointingNodes++;

      mData = newData;

      }

    }

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

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

// also call this from the constructor if the OpenGL context has been created already.

  static void reset()

    {

    NodeData tmp;   

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

      {

      tmp = mMapNodeID.get(key);

      if( tmp.mProjection!=null )

        {

    	  tmp.mTextureID = TEXTURE_NOT_CREATED_YET;

        tmp.mRendered  = false;

        }

      }

    }

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

// PUBLIC API

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

/**

 * Constructs new Node of the Tree.

 *     

 * @param obj DistortedObject to put into the new Node.

 */

  public DistortedNode(DistortedObject obj)

    {

    mObject = obj;

    mParent = null;

    mChildren = null;

    mNumChildren = new int[1];

    mNumChildren[0] = 0;

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

    list.add(obj.getID());

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);  

      }

    }

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

/**

 * Copy-constructs new Node of the Tree 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_BITMAP},  {@link Distorted#CLONE_PRESHADER}, {@link Distorted#CLONE_VERTEX},

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

 *        For example flags = CLONE_BITMAP | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

    mParent = null;

    mObject = node.mObject.deepCopy(flags);

    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.

 */

  public synchronized void attach(DistortedNode node)

    {

    ArrayList<Long> prev = generateIDList(); 

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

    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.

 * 

 * @param obj DistortedObject to initialize our child Node with.

 * @return the newly constructed child Node, or null if we couldn't allocate resources.

 */

  public synchronized DistortedNode attach(DistortedObject obj)

    {

    ArrayList<Long> prev = generateIDList(); 

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

    DistortedNode node = new DistortedNode(obj);

    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.

 * 

 * @param node The Node to remove.

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

 */

  public synchronized boolean detach(DistortedNode node)

    {

    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.

 * 

 * @param obj DistortedObject to remove.

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

 */

  public synchronized boolean detach(DistortedObject obj)

    {

    long id = obj.getID();

    DistortedNode node;

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

      {

      node = mChildren.get(i);

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

        {

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

      }

    }

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

/**

 * Draws the Node, and all its children, to the default framebuffer 0 (i.e. the screen).

 *   

 * @param currTime Current time, in milliseconds.

 */

  public void draw(long currTime)

    {  

    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

    GLES20.glUniform1i(Distorted.mTextureUniformH, 0);  

    markRecursive();

    drawRecursive(currTime,Distorted.mProjection,0);

    }

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

/**

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

 * 

 * @return The DistortedObject contained in the Node.

 */

  public DistortedObject getObject()

    {

    return mObject;

    }

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

// Debug - print all the Node IDs

  public void debug(int depth)

    {

    String tmp="";  

    int i;

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

    tmp += (""+mData.ID);

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

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

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

    }

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

  }