Distorted Android

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

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

// Lesser General Public License for more details.                                               //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

/**

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

  private final InternalChildrenList mChildren;

  private InternalChildrenList.Parent mParent;

  private InternalNodeData mData;

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

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

      mLastTime = currTime;

      }

    return 0;

    }

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

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

    if( input.setAsInput() )

      {

      mState.apply();

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

      mLastTime = currTime;

      }

    return 0;

    }

// return the total number of render calls issued

    if( input.setAsInput() )

      {

      mState.apply();

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

      mLastTime = currTime;

      }

    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;

    }

    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

        {

        height= DEFAULT_FBO_SIZE;

      }

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

      {

      fbo.setProjection(mFOV,mNear);

      }

    return fbo;

  void resetLastTime()

    {

    mLastTime = 0;

    }

    mParent = parent;

// PUBLIC API

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

/**

    mMesh          = mesh;

    mChildren      = new InternalChildrenList(this);

    mNear= InternalOutputSurface.DEFAULT_NEAR;

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

/**

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

    mMesh         = node.mMesh;

    mNear= InternalOutputSurface.DEFAULT_NEAR;

    mFboH            = node.mFboH;

    mFboDepthStencil = node.mFboDepthStencil;

    else

      {

        int w = fbo.getWidth();

        int h = fbo.getHeight();

          }

      mChildren = node.mChildren;

      }

    else

      {

   * Change the input surface while keeping everything else about the Node the same.

   *

   * @param surface The new input surface.

   */

  public void changeInputSurface(InternalSurface surface)

    {

    mSurface = surface;

    }

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

   * 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 FBO contained in this object, even if it is a leaf.

   *

   * @return The DistortedFramebuffer.

   */

  public DistortedFramebuffer getFramebuffer()

    {

    return mData.mFBO;

    }

/**

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

 *

 * @return Mesh contained in the Node.

 */

    return mMesh;

    }

/**

 * Set a new Mesh.

 */

  public void setMesh(MeshBase mesh)

    {

    mMesh = mesh;

    }

/**

    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?

 */

    {

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

    }

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

/**

 * Recursively print all the effect queues attached to the children Nodes and to this Node.

 */