Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

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

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

/**

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

  private InternalNodeData mData;

  private InternalChildrenList mChildren;

  private InternalChildrenList.Parent mParent;

  public void markForDeletion()

    {

      mData.mFBO = null;

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

    {

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

  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

 * @y.exclude

 */

  public void adjustIsomorphism()

      {

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      mData.mFBO = null;

      }

    else if( createNewFBO )

      {

// return the total number of render calls issued

    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.

    if( input.setAsInput() )

      {

      mState.apply();

      }

    return 0;

    }

// return the total number of render calls issued

    if( input.setAsInput() )

      {

      mState.apply();

      }

    return 0;

    }

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

// return the total number of render calls issued

  int renderRecursive(long currTime)

    {

    int numRenders = 0;

      long oldBucket=0, newBucket;

        newBucket = node.getBucket();

        numRenders += node.renderRecursive(currTime);

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

        else oldBucket=newBucket;

      if( mSurface.setAsInput() )

        {

        numRenders++;

    return numRenders;

    }

    int height = mFboH <= 0 ? mEffects.getStartchY() : mFboH;

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

    mParent = parent;

// PUBLIC API

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

/**

    mMesh          = mesh;

    mChildren      = new InternalChildrenList(this);

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

/**

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

    mMesh         = node.mMesh;

    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.

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

/**

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

    }