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

import android.opengl.GLES30;

import org.distorted.library.mesh.MeshBase;

import java.util.ArrayList;

import java.util.Collections;

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

/**

 * 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 (mData.numRender!).

 */

public class DistortedNode implements InternalChildrenList.Parent

  {

  private static final int DEFAULT_FBO_SIZE = 100;

  private MeshBase mMesh;

  private DistortedEffects mEffects;

  private InternalSurface mSurface;

  private InternalRenderState mState;

  private InternalNodeData mData;

  private InternalChildrenList mChildren;

  private InternalChildrenList.Parent mParent;

  private int mFboW, mFboH, mFboDepthStencil;

  private boolean mRenderWayOIT;

  private float mFOV, mNear;

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

  public void markForDeletion()

    {

    if( mData.removeData() )

      {

      mData.mFBO.markForDeletion();

      mData.mFBO = null;

      }

    }

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

// [3] --> the postprocessing queue. See EffectType.

  long getBucket()

    {

    return mEffects.getQueues()[3].getID();

    }

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

  private ArrayList<Long> generateIDList()

    {

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

    int numChildren = mChildren.getNumChildren();

    if( numChildren==0 )

      {

      // add a negative number so this leaf never gets confused with a internal node

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

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

      }

    else

      {

      DistortedNode node;

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

        {

        node = mChildren.getChild(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

      // different order. You will see the number of renders go back to the original 15.

      Collections.sort(ret);

      }

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

    return ret;

    }

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

/**

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

 * InternalChildrenList.Parent interface.

 *

 * @y.exclude

 */

  public void adjustIsomorphism()

    {

    InternalNodeData newData = InternalNodeData.returnData(generateIDList());

    boolean deleteOldFBO = mData.removeData();

    boolean createNewFBO = (mChildren.getNumChildren()>0 && newData.mFBO==null);

    if( deleteOldFBO && createNewFBO )

      {

      newData.mFBO = mData.mFBO;

      }

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      mData.mFBO = null;

      }

    else if( createNewFBO )

      {

      newData.mFBO = allocateNewFBO();

      }

    mData = newData;

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

    }

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

// return the total number of render calls issued

  int drawNoBlend(long currTime, InternalOutputSurface surface)

    {

    InternalSurface input = getSurface();

    if( input.setAsInput() )

      {

      mState.apply();

      GLES30.glDisable(GLES30.GL_BLEND);

      DistortedLibrary.drawPriv(mEffects, mMesh, surface, currTime);

      GLES30.glEnable(GLES30.GL_BLEND);

      return 1;

      }

    return 0;

    }

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

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

  int drawOIT(long currTime, InternalOutputSurface surface)

    {

    InternalSurface input = getSurface();

    if( input.setAsInput() )

      {

      mState.apply();

      DistortedLibrary.drawPrivOIT(mEffects, mMesh, surface, currTime);

      return 1;

      }

    return 0;

    }

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

// return the total number of render calls issued

  int draw(long currTime, InternalOutputSurface surface)

    {

    InternalSurface input = getSurface();

    if( input.setAsInput() )

      {

      mState.apply();

      DistortedLibrary.drawPriv(mEffects, mMesh, surface, currTime);

      return 1;

      }

    return 0;

    }

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

// return the total number of render calls issued

  int renderRecursive(long currTime)

    {

    int numRenders = 0;

    int numChildren = mChildren.getNumChildren();

    if( numChildren>0 && mData.notRenderedYetAtThisTime(currTime) )

      {

      DistortedNode node;

      long oldBucket=0, newBucket;

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

        {

        node = mChildren.getChild(i);

        newBucket = node.getBucket();

        numRenders += node.renderRecursive(currTime);

        if( newBucket<oldBucket ) mChildren.rearrangeByBuckets(i,newBucket);

        else oldBucket=newBucket;

        }

      if( mData.mFBO==null ) mData.mFBO = allocateNewFBO();

      mData.mFBO.setAsOutput(currTime);

      if( mSurface.setAsInput() )

        {

        numRenders++;

        DistortedLibrary.blitPriv(mData.mFBO);

        }

      numRenders += mData.mFBO.renderChildren(currTime,numChildren,mChildren,0, mRenderWayOIT);

      }

    return numRenders;

    }

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

  private DistortedFramebuffer allocateNewFBO()

    {

    int width, height;

    if( mFboW>0 && mFboH>0 )

      {

      width = mFboW;

      height= mFboH;

      }

    else

      {

      if( mSurface instanceof DistortedFramebuffer )

        {

        DistortedFramebuffer fbo = (DistortedFramebuffer)mSurface;

        width = fbo.mWidth;

        height= fbo.mHeight;

        }

      else

        {

        width = DEFAULT_FBO_SIZE;

        height= DEFAULT_FBO_SIZE;

        }

      }

    DistortedFramebuffer fbo = new DistortedFramebuffer(1,mFboDepthStencil, InternalSurface.TYPE_TREE, width, height);

    if( mFOV!=InternalOutputSurface.DEFAULT_FOV || mNear!=InternalOutputSurface.DEFAULT_NEAR )

      {

      fbo.setProjection(mFOV,mNear);

      }

    return fbo;

    }

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

  void setParent(InternalChildrenList.Parent parent)

    {

    mParent = parent;

    }

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

// 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 MeshBase to put into the new Node.

 */

  public DistortedNode(InternalSurface surface, DistortedEffects effects, MeshBase mesh)

    {

    mSurface       = surface;

    mEffects       = effects;

    mMesh          = mesh;

    mState         = new InternalRenderState();

    mChildren      = new InternalChildrenList(this);

    mParent        = null;

    mRenderWayOIT  = false;

    mFOV = InternalOutputSurface.DEFAULT_FOV;

    mNear= InternalOutputSurface.DEFAULT_NEAR;

    mFboW            = 0;  // i.e. take this from

    mFboH            = 0;  // mEffects's stretch{X,Y}

    mFboDepthStencil = DistortedFramebuffer.DEPTH_NO_STENCIL;

    mData = InternalNodeData.returnData(generateIDList());

    }

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

/**

 * 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 DistortedLibrary#CLONE_SURFACE},  {@link DistortedLibrary#CLONE_MATRIX}, {@link DistortedLibrary#CLONE_VERTEX},

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

 *        For example flags = CLONE_SURFACE | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

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

    mMesh         = node.mMesh;

    mState        = new InternalRenderState();

    mParent       = null;

    mRenderWayOIT = false;

    mFOV = InternalOutputSurface.DEFAULT_FOV;

    mNear= InternalOutputSurface.DEFAULT_NEAR;

    mFboW            = node.mFboW;

    mFboH            = node.mFboH;

    mFboDepthStencil = node.mFboDepthStencil;

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

      {

      mSurface = node.mSurface;

      }

    else

      {

      if( node.mSurface instanceof DistortedTexture )

        {

        mSurface = new DistortedTexture(InternalSurface.TYPE_TREE);

        }

      else if( node.mSurface instanceof DistortedFramebuffer )

        {

        DistortedFramebuffer fbo = (DistortedFramebuffer)node.mSurface;

        int w = fbo.getWidth();

        int h = fbo.getHeight();

        int depthStencil = DistortedFramebuffer.NO_DEPTH_NO_STENCIL;

        if( fbo.hasDepth() )

          {

          boolean hasStencil = fbo.hasStencil();

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

          }

        mSurface = new DistortedFramebuffer(1,depthStencil, InternalSurface.TYPE_TREE,w,h);

        }

      }

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

      {

      mChildren = node.mChildren;

      }

    else

      {

      mChildren = new InternalChildrenList(this);

      }

    mData = InternalNodeData.returnData(generateIDList());

    }

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

  /**

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

      DistortedLibrary.setSSBOSize(initialSize);

    }

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

/**

 * 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

 * InternalMaster (by calling doWork())

 *

 * @param node The new Node to add.

 */

  public void attach(DistortedNode node)

    {

    mChildren.attach(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

 * InternalMaster (by calling doWork())

 *

 * @param surface InputSurface to initialize our child Node with.

 * @param effects DistortedEffects to initialize our child Node with.

 * @param mesh MeshBase to initialize our child Node with.

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

 */

  public DistortedNode attach(InternalSurface surface, DistortedEffects effects, MeshBase mesh)

    {

    return mChildren.attach(surface,effects,mesh);

    }

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

/**

 * 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

 * InternalMaster (by calling doWork())

 *

 * @param node The Node to remove.

 */

  public void detach(DistortedNode node)

    {

    mChildren.detach(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

 * InternalMaster (by calling doWork())

 *

 * @param effects DistortedEffects to remove.

 */

  public void detach(DistortedEffects effects)

    {

    mChildren.detach(effects);

    }

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

/**

 * Removes all children Nodes.

 * <p>

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

 * InternalMaster (by calling doWork())

 */

  public void detachAll()

    {

    mChildren.detachAll();

    }

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

/**

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

 * 

 * @return The DistortedEffects contained in the Node.

 */

  public DistortedEffects getEffects()

    {

    return mEffects;

    }

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

  /**

   * Returns the surface this object gets rendered to.

   *

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

   */

  public InternalSurface getSurface()

    {

    return mChildren.getNumChildren()==0 ? mSurface : mData.mFBO;

    }

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

/**

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

 *

 * @return Mesh contained in the Node.

 */

  public MeshBase getMesh()

    {

    return mMesh;

    }

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

/**

 * Resizes the DistortedFramebuffer object that we render this Node to.

 */

  public void resizeFBO(int width, int height)

    {

    mFboW = width;

    mFboH = height;

    if ( mData.mFBO !=null )

      {

      // TODO: potentially allocate a new NodeData if we have to

      mData.mFBO.resize(width,height);

      }

    }

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

/**

 * Set Projection Matrix for the Framebuffer contained in this Node.

 * <p>

 * If this Node is a Leaf and has no Framebuffer in it, this call does nothing.

 *

 * @param fov Vertical 'field of view' of the Projection frustrum (in degrees).

 *            Valid values: 0<=fov<180. FOV==0 means 'parallel projection'.

 * @param near The Near plane.

 */

  public void setProjection(float fov, float near)

    {

    if( fov < 180.0f && fov >=0.0f )

      {

      mFOV = fov;

      }

    if( near<   1.0f && near> 0.0f )

      {

      mNear= near;

      }

    else if( near<=0.0f )

      {

      mNear = 0.01f;

      }

    else if( near>=1.0f )

      {

      mNear=0.99f;

      }

    if( mData.mFBO!=null )

      {

      mData.mFBO.setProjection(mFOV,mNear);

      }

    }

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

/**

 * Enables/disables DEPTH and STENCIL buffers in the Framebuffer object that we render this Node to.

 */

  public void enableDepthStencil(int depthStencil)

    {

    mFboDepthStencil = depthStencil;

    if ( mData.mFBO !=null )

      {

      // TODO: potentially allocate a new NodeData if we have to

      mData.mFBO.enableDepthStencil(depthStencil);

      }

    }

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

// APIs that control how to set the OpenGL state just before rendering this Node.

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

/**

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

 */

  @SuppressWarnings("unused")

  public void glColorMask(boolean r, boolean g, boolean b, boolean a)

    {

    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?

 */

  @SuppressWarnings("unused")

  public void glDepthMask(boolean mask)

    {

    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.

 */

  @SuppressWarnings("unused")

  public void glStencilMask(int mask)

    {

    mState.glStencilMask(mask);

    }

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

/**

 * When rendering this Node, which Tests to enable?

 *

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

 */

  @SuppressWarnings("unused")

  public void glEnable(int test)

    {

    mState.glEnable(test);

    }

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

/**

 * When rendering this Node, which Tests to enable?

 *

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

 */

  @SuppressWarnings("unused")

  public void glDisable(int test)

    {

    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.

 */

  @SuppressWarnings("unused")

  public void glStencilFunc(int func, int ref, int mask)

    {

    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.

 */

  @SuppressWarnings("unused")

  public void glStencilOp(int sfail, int dpfail, int dppass)

    {

    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

 */

  @SuppressWarnings("unused")

  public void glDepthFunc(int func)

    {

    mState.glDepthFunc(func);

    }

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

/**

 * When rendering this Node, use the following Blending mode.

 * <p>

 * Valid values: GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,

 *               GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR,

 *               GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_SRC_ALPHA_SATURATE

 *

 * @param src Source Blend function

 * @param dst Destination Blend function

 */

  @SuppressWarnings("unused")

  public void glBlendFunc(int src, int dst)

    {

    mState.glBlendFunc(src,dst);

    }

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

/**

 * Before rendering this Node, clear the following buffers.

 * <p>

 * Valid values: 0, or bitwise OR of one or more values from the set GL_COLOR_BUFFER_BIT,

 *               GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT.

 * Default: 0

 *

 * @param mask bitwise OR of BUFFER_BITs to clear.

 */

  @SuppressWarnings("unused")

  public void glClear(int mask)

    {

    mState.glClear(mask);

    }

  }