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

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

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

/**

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

      type = t;

      node = n;

      }

    }

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

  private static long mNextNodeID =0;

    {

    final ArrayList<Long> key;

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

  public void markForDeletion()

    {

    if( --mData.numPointingNodes==0 )

      {

      mMapNodeID.remove(mData.key);

      if( mData.mFBO!=null )

        {

        mData.mFBO.markForDeletion();

        mData.mFBO = null;

        }

      }

    mEffects.removeNode(this);

    }

  private ArrayList<Long> generateIDList()

    {

    if( mNumChildren[0]==0 )

      {

      // with a single child that happens to have ID identical to some leaf's Effects ID.

      }

        {

        node = mChildren.get(i);

        ret.add(node.mData.ID);

        }

      // A bit questionable decision here - we are sorting the children IDs, which means

      // that order in which we draw the children is going to be undefined (well, this is not

      // strictly speaking true - when rendering, if no postprocessing and isomorphism are

      // involved, we *DO* render the children in order they were added; if however there

      // are two internal nodes with the same list of identical children, just added in a

      // different order each time, then we consider them isomorphic, i.e. identical and only

      // render the first one. If then two children of such 'pseudo-isomorphic' nodes are at

      // exactly the same Z-height this might result in some unexpected sights).

      //

      // Reason: with the children being sorted by postprocessing buckets, the order is

      // undefined anyway (although only when postprocessing is applied).

      //

      // See the consequences in the 'Olympic' app - remove a few leaves and add them back in

      }

    ret.add( 0, mSurface.getID() );

    }

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

      }

    }

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

// tree isomorphism algorithm

  private void adjustIsomorphism()

    {

    NodeData newData = retData();

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

      }

      {

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

      }

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      mData.mFBO = null;

      }

    else if( createNewFBO )

      {

      int height = mFboH <= 0 ? mSurface.getHeight() : mFboH;

// return the total number of render calls issued

  int drawNoBlend(long currTime, DistortedOutputSurface surface)

    {

    if( input.setAsInput() )

      {

      mState.apply();

      GLES31.glDisable(GLES31.GL_BLEND);

      return 1;

      }

    return 0;

    }

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

// Use the Order Independent Transparency method to draw a non-postprocessed child.

  int drawOIT(long currTime, DistortedOutputSurface surface)

    {

    if( input.setAsInput() )

      {

      mState.apply();

      }

    return 0;

    }

// return the total number of render calls issued

  int draw(long currTime, DistortedOutputSurface surface)

    {

    if( input.setAsInput() )

      {

      mState.apply();

      }

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

        }

        {

        int height = mFboH <= 0 ? mSurface.getHeight() : mFboH;

      if( mSurface.setAsInput() )

        {

        numRenders++;

        DistortedEffects.blitPriv(mData.mFBO);

        }

    return numRenders;

    }

  void setSurfaceParent(DistortedOutputSurface dep)

    {

    mSurfaceParent = dep;

    mParent = null;

    }

  void sort()

    {

    if( mParent!=null )

      {

      mParent.mChildren.remove(this);

    else if( mSurfaceParent!=null )

      {

      ArrayList<DistortedNode> children = mSurfaceParent.getChildren();

      children.remove(this);

    }

  EffectQueuePostprocess getPostprocessQueue()

    return mEffects.getPostprocess();

    }

// PUBLIC API

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

/**

    mMesh          = mesh;

    mNumChildren   = new int[1];

    mFboH            = 0;  // mSurface's dimensions

    mFboDepthStencil = DistortedFramebuffer.DEPTH_NO_STENCIL;

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

/**

    mMesh         = node.mMesh;

    mState        = new DistortedRenderState();

    mParent       = null;

    mSurfaceParent= null;

    mFboH            = node.mFboH;

    mFboDepthStencil = node.mFboDepthStencil;

    else

      {

      int h = node.mSurface.getHeight();

        if( ((DistortedFramebuffer) node.mSurface).hasDepth() )

          {

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

          depthStencil = (hasStencil ? DistortedFramebuffer.BOTH_DEPTH_STENCIL:DistortedFramebuffer.DEPTH_NO_STENCIL);

          }

        {

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

        }

      mNumChildren = node.mNumChildren;

      }

    else

      {

      mChildren = null;

      mNumChildren = new int[1];

      }

  /**

   * When rendering this Node, should we use the Order Independent Transparency render more?

   * <p>

   * There are two modes of rendering: the fast 'normal' way, which however renders transparent

   * fragments in different ways depending on which fragments get rendered first, or the slower

   * 'oit' way, which renders transparent fragments correctly regardless of their order.

   *

   * @param oit True if we want to render more slowly, but in a way which accounts for transparency.

   */

  public void setOrderIndependentTransparency(boolean oit)

    {

    mRenderWayOIT = oit;

    }

  /**

   * When rendering this Node, should we use the Order Independent Transparency render more?

   * <p>

   * There are two modes of rendering: the fast 'normal' way, which however renders transparent

   * fragments in different ways depending on which fragments get rendered first, or the slower

   * 'oit' way, which renders transparent fragments correctly regardless of their order.

   *

   * @param oit True if we want to render more slowly, but in a way which accounts for transparency.

   * @param initialSize Initial number of transparent fragments we expect, in screenfulls.

   *                    I.e '1.0' means 'the scene we are going to render contains about 1 screen

   *                    worth of transparent fragments'. Valid values: 0.0 < initialSize < 10.0

   *                    Even if you get this wrong, the library will detect that there are more

   *                    transparent fragments than it has space for and readjust its internal buffers,

   *                    but only after a few frames during which one will probably see missing objects.

   */

  public void setOrderIndependentTransparency(boolean oit, float initialSize)

    {

    mRenderWayOIT = oit;

    if( initialSize>0.0f && initialSize<10.0f )

      DistortedEffects.setSSBOSize(initialSize);

    }

/**

 * 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

 */

/**

 * 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

 */

    }

/**

 * 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

 */

/**

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

      }

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

    {

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

/**

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

 * @y.exclude

      int numChanges=0;

        switch(job.type)

          {

          case ATTACH: numChanges++;

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

                       job.node.mParent = this;

                       mNumChildren[0]++;

                       break;

          case DETACH: numChanges++;

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

                         job.node.mSurfaceParent = null;

                         mNumChildren[0]--;

          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;

                           tmp.mSurfaceParent = null;

                           }

                         }

                       break;

          case SORT  : mChildren.remove(job.node);

                       DistortedMaster.addSortingByBuckets(mChildren,job.node);

                       break;

          }

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

/**

  /**

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

   *

   * @return The DistortedSurface contained in the Node (if a leaf), or the FBO (if an internal Node)