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 DistortedChildrenList.Parent mParent;

  public void markForDeletion()

    {

      mData.mFBO = null;

    mEffects.removeNode(this);

    }

  private ArrayList<Long> generateIDList()

    {

      // with a single child that happens to have ID identical to some leaf's Effects 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() );

    }

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

 * DistortedChildrenList.Parent interface.

 *

 * @y.exclude

 */

  public void adjustIsomorphism()

    boolean deleteOldFBO = mData.removeData();

      {

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      mData.mFBO = null;

      }

    else if( createNewFBO )

      {

/**

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

 * DistortedChildrenList.Parent interface.

 *

 * @y.exclude

 */

  public DistortedChildrenList getChildren()

    {

    return mChildren;

    }

// 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( mSurface.setAsInput() )

        {

        numRenders++;

        DistortedEffects.blitPriv(mData.mFBO);

        }

    return numRenders;

    }

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

    return new DistortedFramebuffer(1,mFboDepthStencil, DistortedSurface.TYPE_TREE, width, height);

    }

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

  void setParent(DistortedChildrenList.Parent parent)

    {

    mParent = parent;

  void sort()

    {

    if( mParent!=null )

      {

      siblings.removeChild(this);

      siblings.addSortingByBuckets(this);

    }

  EffectQueuePostprocess getPostprocessQueue()

    return mEffects.getPostprocess();

    }

// PUBLIC API

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

/**

    mMesh          = mesh;

    mFboH            = 0;  // mSurface's dimensions

    mFboDepthStencil = DistortedFramebuffer.DEPTH_NO_STENCIL;

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

/**

    mMesh         = node.mMesh;

    mState        = new DistortedRenderState();

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

          }

      mChildren = node.mChildren;

      }

    else

      {

  /**

   * 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

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

/**

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

    {

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

/**

  /**

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

   */

  public DistortedSurface getInternalSurface()

    {

/**

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

 *

 * @return Mesh contained in the Node.

 */

    return mMesh;

    }

/**

    mFboH = height;

    if ( mData.mFBO !=null )

      {

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

      mData.mFBO.resize(width,height);

      }

    }

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

/**

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

 */

    {

    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

 */

    {

    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

 */

    {

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

    }