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;

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

/**

 * 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

  private static final int DETACH = 1;

  private static final int DETALL = 2;

  private static final int SORT   = 3;

  private ArrayList<DistortedNode> mChildren;

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

  private class Job

    {

    int type;

    DistortedNode node;

    DistortedEffectsPostprocess dep;

    Job(int t, DistortedNode n, DistortedEffectsPostprocess d)

      {

      type = t;

      node = n;

      dep  = d;

      }

    }

  private ArrayList<Job> mJobs = new ArrayList<>();

  private static long mNextNodeID =0;

    {

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

  private ArrayList<Long> generateIDList()

    {

    if( mNumChildren[0]==0 )

      {

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

      }

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

      {

      node = mChildren.get(i);

      ret.add(node.mData.ID);

      }

    return ret;

    }

// Debug - print all the Node IDs

    {

    String tmp="";

    int i;

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

            " parent sID="+(mParent==null ? "null": (mParent.mSurface.getID()));

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

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

    }

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

// Debug - print contents of the HashMap

    {

    NodeData tmp;

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

      {

      tmp = mMapNodeID.get(key);

      }

    }

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

    ArrayList<Long> newList = generateIDList();

    NodeData newData = mMapNodeID.get(newList);

      {

      newData.numPointingNodes++;

      }

    else

      }

    boolean createNewFBO = false;

      if( mData.mFBO!=null ) deleteOldFBO=true;

      }

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

      {

      createNewFBO = true;

      }

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

      {

      newData.mFBO.markForDeletion();

      android.util.Log.d("NODE", "ERROR!! this NodeData cannot possibly contain a non-null FBO!! "+newData.mFBO.getID() );

      newData.mFBO = null;

      }

      {

      newData.mFBO = mData.mFBO;  // just copy over

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      }

    else if( createNewFBO )

      {

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

// return the total number of render calls issued

  int draw(long currTime, DistortedOutputSurface surface)

    {

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

    if( input.setAsInput() )

      {

      mState.apply();

      mEffects.drawPriv(mSurface.getWidth()/2.0f, mSurface.getHeight()/2.0f, mMesh, surface, currTime);

      return 1;

      }

    return 0;

    }

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

// return the total number of render calls issued

  int renderRecursive(long currTime)

    {

    int numRenders = 0;

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

      {

      mData.currTime = currTime;

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

        {

        numRenders += mChildren.get(i).renderRecursive(currTime);

        }

      if( mSurface.setAsInput() )

        {

        numRenders++;

        DistortedEffects.blitPriv(mData.mFBO);

        }

    return numRenders;

    }

  private void newJob(int t, DistortedNode n, DistortedEffectsPostprocess d)

    {

    mJobs.add(new Job(t,n,d));

    }

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

  void setPost(DistortedEffectsPostprocess dep)

    {

    mPostprocess = dep;

    }

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

  void setSurfaceParent(DistortedOutputSurface dep)

    {

    mSurfaceParent = dep;

    mParent = null;

    }

// PUBLIC API

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

/**

    mNumChildren   = new int[1];

    mNumChildren[0]= 0;

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

    }

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

/**

    mPostprocess  = null;

    mMesh         = node.mMesh;

    mState        = new DistortedRenderState();

    mParent       = null;

    mSurfaceParent= null;

    else

      {

      int h = node.mSurface.getHeight();

        {

        node.mChildren = new ArrayList<>(2);

        }

      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

      {

      }

    }

/**

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

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 */

    DistortedMaster.newSlave(this);

/**

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

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 */

    DistortedMaster.newSlave(this);

    }

/**

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

 * We cannot do this mid-render - actual detachment will be done just before the next render, by the

 */

    DistortedMaster.newSlave(this);

/**

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

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

 * We cannot do this mid-render - actual detachment will be done just before the next render, by the

      {

      node = mChildren.get(i);

        mJobs.add(new Job(DETACH,node,null));

        DistortedMaster.newSlave(this);

      }

    if( !detached )

      {

      // if we failed to detach any, it still might be the case that

      int num = mJobs.size();

      Job job;

        {

        job = mJobs.get(i);

        if( job.type==ATTACH && job.node.getEffects()==effects )

          {

          mJobs.remove(i);

          break;

          }

        }

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

/**

 * Removes all children Nodes.

 * <p>

 * We cannot do this mid-render - actual detachment will be done just before the next render, by the

  public void detachAll()

    {

    DistortedMaster.newSlave(this);

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

/**

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

 * @y.exclude

    Job job;

    int numChanges=0;

    for(int i=0; i<num; i++)

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

                     job.node.mParent = this;

                     DistortedMaster.addSorted(mChildren,job.node);

                     break;

        case DETACH: numChanges++;

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

                       {

                       job.node.mParent = null;

                       }

                     break;

        case DETALL: numChanges++;

                     if( mNumChildren[0]>0 )

                       {

                       DistortedNode tmp;

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

                         {

                         tmp = mChildren.remove(j);

                         tmp.mParent = null;

                       mNumChildren[0] = 0;

                       }

                     break;

                     mChildren.remove(job.node);

                     DistortedMaster.addSorted(mChildren,job.node);

/**

 * Sets the Postprocessing Effects we will apply to the temporary buffer this Node - and fellow siblings

 * with the same Effects - will get rendered to.

 * <p>

 * For efficiency reasons, it is very important to assign the very same DistortedEffectsPostprocess

 * object to all the DistortedNode siblings that are supposed to be postprocessed in the same way,

 * because only then will the library assign all such siblings to the same 'Bucket' which gets rendered

 * to the same offscreen buffer which then gets postprocessed in one go and subsequently merged to the

 * target Surface.

 */

  public void setPostprocessEffects(DistortedEffectsPostprocess dep)

    {

      {

      mParent.newJob(SORT, this, dep);

      DistortedMaster.newSlave(mParent);

      }

    else if( mSurfaceParent!=null )

      {

      mSurfaceParent.newJob(SORT, this, dep);

      DistortedMaster.newSlave(mSurfaceParent);

      }

    else

      {

      mPostprocess = dep;

      }

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

 *

 * @return The DistortedEffectsPostprocess contained in the Node.

 */

  public DistortedEffectsPostprocess getEffectsPostprocess()

    {

    return mPostprocess;

    }

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

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

/**

/**

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

 *

 * @return The DistortedFramebuffer contained in the Node.

 */

  public DistortedFramebuffer getFramebuffer()

    {

    return mData.mFBO;

    }

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

/**

 * When rendering this Node, use ColorMask (r,g,b,a).

 *

 * @param r Write to the RED color channel when rendering this Node?

 * @param g Write to the GREEN color channel when rendering this Node?

 * @param b Write to the BLUE color channel when rendering this Node?

 * @param a Write to the ALPHA channel when rendering this Node?

 */

    {

    mState.glColorMask(r,g,b,a);

    }

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

/**

 * When rendering this Node, switch on writing to Depth buffer?

 *

 * @param mask Write to the Depth buffer when rendering this Node?

 */

    {

    mState.glDepthMask(mask);

    }

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

/**

 * When rendering this Node, which bits of the Stencil buffer to write to?

 *

 * @param mask Marks the bits of the Stencil buffer we will write to when rendering this Node.

 */

    {

    mState.glStencilMask(mask);

    }

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

/**

 * When rendering this Node, which Tests to enable?

 *

 * @param test Valid values: GL_DEPTH_TEST, GL_STENCIL_TEST, GL_BLEND

 */

    {

    mState.glEnable(test);

    }

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

/**

 * When rendering this Node, which Tests to enable?

 *

 * @param test Valid values: GL_DEPTH_TEST, GL_STENCIL_TEST, GL_BLEND

 */

    {

    mState.glDisable(test);

    }

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

/**

 * When rendering this Node, use the following StencilFunc.

 *

 * @param func Valid values: GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL

 * @param ref  Reference valut to compare our stencil with.

 * @param mask Mask used when comparing.

 */

    {

    mState.glStencilFunc(func,ref,mask);

    }

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

/**

 * When rendering this Node, use the following StencilOp.

 * <p>

 * Valid values of all 3 parameters: GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP

 *

 * @param sfail  What to do when Stencil Test fails.

 * @param dpfail What to do when Depth Test fails.

 * @param dppass What to do when Depth Test passes.

 */

    {

    mState.glStencilOp(sfail,dpfail,dppass);

    }

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

/**

 * When rendering this Node, use the following DepthFunc.

 *

 * @param func Valid values: GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL

 */