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;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

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

/**

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

  {

  private static final int ATTACH = 0;

  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;

    DistortedEffectsPostprocess dep;

    Job(int t, DistortedNode n, DistortedEffectsPostprocess d)

      {

      type = t;

      node = n;

      dep  = d;

      }

    }

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

  private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();

  private static long mNextNodeID =0;

  private DistortedNode mParent;

  private DistortedOutputSurface mSurfaceParent;

  private MeshObject mMesh;

  private DistortedEffects mEffects;

  private DistortedEffectsPostprocess mPostprocess;

  private DistortedInputSurface mSurface;

  private DistortedRenderState mState;

  private NodeData mData;

  private class NodeData

    {

    long ID;

    int numPointingNodes;

    long currTime;

    ArrayList<Long> key;

    DistortedFramebuffer mFBO;

    NodeData(long id, ArrayList<Long> k)

      {

      ID              = id;

      key             = k;

      numPointingNodes= 1;

      currTime        =-1;

      mFBO            = null;

      }

    }

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

  static synchronized void onPause()

    {

    NodeData data;

    for (HashMap.Entry<ArrayList<Long>,NodeData> entry : mMapNodeID.entrySet())

      {

      data = entry.getValue();

      if( data.mFBO != null )

        {

        data.mFBO.markForDeletion();

        data.mFBO = null;

        }

      }

    }

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

  static synchronized void onDestroy()

    {

    mNextNodeID = 0;

    mMapNodeID.clear();

    }

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

  private ArrayList<Long> generateIDList()

    {

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

    if( mNumChildren[0]==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<mNumChildren[0]; i++)

        {

        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

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

      Collections.sort(ret);

      }

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

    return ret;

    }

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

// Debug - print all the Node IDs

  @SuppressWarnings("unused")

  void debug(int depth)

    {

    String tmp="";

    int i;

    for(i=0; i<depth; i++) tmp +="   ";

    tmp += ("NodeID="+mData.ID+" nodes pointing: "+mData.numPointingNodes+" surfaceID="+

            mSurface.getID()+" FBO="+(mData.mFBO==null ? "null":mData.mFBO.getID()))+

            " parent sID="+(mParent==null ? "null": (mParent.mSurface.getID()));

    android.util.Log.e("NODE", tmp);

    for(i=0; i<mNumChildren[0]; i++)

      mChildren.get(i).debug(depth+1);

    }

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

// Debug - print contents of the HashMap

  @SuppressWarnings("unused")

  static void debugMap()

    {

    NodeData tmp;

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      android.util.Log.e("NODE", "NodeID: "+tmp.ID+" <-- "+key);

      }

    }

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

// tree isomorphism algorithm

  private void adjustIsomorphism()

    {

    ArrayList<Long> newList = generateIDList();

    NodeData newData = mMapNodeID.get(newList);

    if( newData!=null )

      {

      newData.numPointingNodes++;

      }

    else

      {

      newData = new NodeData(++mNextNodeID,newList);

      mMapNodeID.put(newList,newData);

      }

    boolean deleteOldFBO = false;

    boolean createNewFBO = false;

    if( --mData.numPointingNodes==0 )

      {

      mMapNodeID.remove(mData.key);

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

      android.util.Log.d("NODE", "ERROR!! this NodeData cannot possibly contain a non-null FBO!! "+newData.mFBO.getID() );

      newData.mFBO = null;

      }

    if( deleteOldFBO && createNewFBO )

      {

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

      //android.util.Log.d("NODE", "copying over FBOs "+mData.mFBO.getID() );

      }

    else if( deleteOldFBO )

      {

      mData.mFBO.markForDeletion();

      //android.util.Log.d("NODE", "deleting old FBO "+mData.mFBO.getID() );

      mData.mFBO = null;

      }

    else if( createNewFBO )

      {

      newData.mFBO = new DistortedFramebuffer(DistortedFramebuffer.DEPTH_NO_STENCIL, DistortedSurface.TYPE_TREE, mSurface.getWidth(),mSurface.getHeight());

      //android.util.Log.d("NODE", "creating new FBO "+newData.mFBO.getID() );

      }

    mData = newData;

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

    }

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

// return the total number of render calls issued

  int draw(long currTime, DistortedOutputSurface surface)

    {

    DistortedInputSurface input = mNumChildren[0]==0 ? mSurface : mData.mFBO;

    if( input.setAsInput() )

      {

      mState.apply();

      mEffects.drawPriv(mSurface.getWidth()/2.0f, mSurface.getHeight()/2.0f, mMesh, surface, currTime);

      return 1;

      }

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

        }

      if( mData.mFBO==null )

        {

        mData.mFBO = new DistortedFramebuffer(DistortedFramebuffer.DEPTH_NO_STENCIL, DistortedSurface.TYPE_TREE, mSurface.getWidth(),mSurface.getHeight());

        }

      mData.mFBO.setAsOutput(currTime);

      if( mSurface.setAsInput() )

        {

        numRenders++;

        DistortedEffects.blitPriv(mData.mFBO);

        }

      numRenders += mData.mFBO.renderChildren(currTime,mNumChildren[0],mChildren);

      }

    return numRenders;

    }

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

  private void newJob(int t, DistortedNode n, DistortedEffectsPostprocess d)

    {

    mJobs.add(new Job(t,n,d));

    }

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

  void setPost(DistortedEffectsPostprocess dep)

    {

    mPostprocess = dep;

    }

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

  void setSurfaceParent(DistortedOutputSurface dep)

    {

    mSurfaceParent = dep;

    mParent = null;

    }

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

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

 */

  public DistortedNode(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    {

    mSurface       = surface;

    mEffects       = effects;

    mPostprocess   = null;

    mMesh          = mesh;

    mState         = new DistortedRenderState();

    mChildren      = null;

    mNumChildren   = new int[1];

    mNumChildren[0]= 0;

    mParent        = null;

    mSurfaceParent = null;

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

    list.add(mSurface.getID());

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

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID,list);

      mMapNodeID.put(list, mData);

      }

    }

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

/**

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

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

 *        For example flags = CLONE_SURFACE | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

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

    mPostprocess  = null;

    mMesh         = node.mMesh;

    mState        = new DistortedRenderState();

    mParent       = null;

    mSurfaceParent= null;

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

      {

      mSurface = node.mSurface;

      }

    else

      {

      int w = node.mSurface.getWidth();

      int h = node.mSurface.getHeight();

      if( node.mSurface instanceof DistortedTexture )

        {

        mSurface = new DistortedTexture(w,h, DistortedSurface.TYPE_TREE);

        }

      else if( node.mSurface instanceof DistortedFramebuffer )

        {

        int depthStencil = DistortedFramebuffer.NO_DEPTH_STENCIL;

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

          {

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

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

          }

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

        }

      }

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

      {

      if( node.mChildren==null )     // do NOT copy over the NULL!

        {

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

        }

      mChildren = node.mChildren;

      mNumChildren = node.mNumChildren;

      }

    else

      {

      mChildren = null;

      mNumChildren = new int[1];

      mNumChildren[0] = 0;

      }

    ArrayList<Long> list = generateIDList();

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID,list);

      mMapNodeID.put(list, mData);

      }

    }

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

/**

 * 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

 * DistortedMaster (by calling doWork())

 *

 * @param node The new Node to add.

 */

  public void attach(DistortedNode node)

    {

    mJobs.add(new Job(ATTACH,node,null));

    DistortedMaster.newSlave(this);

    }

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

/**

 * 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

 * DistortedMaster (by calling doWork())

 *

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

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

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

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

 */

  public DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    {

    DistortedNode node = new DistortedNode(surface,effects,mesh);

    mJobs.add(new Job(ATTACH,node,null));

    DistortedMaster.newSlave(this);

    return node;

    }

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

/**

 * 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

 * DistortedMaster (by calling doWork())

 *

 * @param node The Node to remove.

 */

  public void detach(DistortedNode node)

    {

    mJobs.add(new Job(DETACH,node,null));

    DistortedMaster.newSlave(this);

    }

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

/**

 * 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

 * DistortedMaster (by calling doWork())

 *

 * @param effects DistortedEffects to remove.

 */

  public void detach(DistortedEffects effects)

    {

    long id = effects.getID();

    DistortedNode node;

    boolean detached = false;

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      if( node.getEffects().getID()==id )

        {

        detached = true;

        mJobs.add(new Job(DETACH,node,null));

        DistortedMaster.newSlave(this);

        break;

        }

      }

    if( !detached )

      {

      // if we failed to detach any, it still might be the case that

      // there's an ATTACH job that we need to cancel.

      int num = mJobs.size();

      Job job;

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

        {

        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

 * DistortedMaster (by calling doWork())

 */

  public void detachAll()

    {

    mJobs.add(new Job(DETALL,null,null));

    DistortedMaster.newSlave(this);

    }

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

/**

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

 * DistortedSlave interface, which should really be a class that we extend here instead but

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void doWork()

    {

    int num = mJobs.size();

    Job job;

    int numChanges=0;

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

      {

      job = mJobs.remove(0);

      switch(job.type)

        {

        case ATTACH: numChanges++;

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

                     job.node.mParent = this;

                     job.node.mSurfaceParent = null;

                     DistortedMaster.addSorted(mChildren,job.node);

                     mNumChildren[0]++;

                     break;

        case DETACH: numChanges++;

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

                       {

                       job.node.mParent = null;

                       job.node.mSurfaceParent = null;

                       mNumChildren[0]--;

                       }

                     break;

        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;

                         }

                       mNumChildren[0] = 0;

                       }

                     break;

        case SORT  : job.node.mPostprocess = job.dep;

                     mChildren.remove(job.node);

                     DistortedMaster.addSorted(mChildren,job.node);

                     break;

        }

      }

    if( numChanges>0 ) adjustIsomorphism();

    }

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

/**

 * Sets the Postprocessing Effects we will apply to the temporary buffer this Node - and fellow siblings

 * with the same Effects - will get rendered to.

 * <p>

 * For efficiency reasons, it is very important to assign the very same DistortedEffectsPostprocess

 * object to all the DistortedNode siblings that are supposed to be postprocessed in the same way,

 * because only then will the library assign all such siblings to the same 'Bucket' which gets rendered

 * to the same offscreen buffer which then gets postprocessed in one go and subsequently merged to the

 * target Surface.

 */

  public void setPostprocessEffects(DistortedEffectsPostprocess dep)

    {

    if( mParent!=null )

      {

      mParent.newJob(SORT, this, dep);

      DistortedMaster.newSlave(mParent);

      }

    else if( mSurfaceParent!=null )

      {

      mSurfaceParent.newJob(SORT, this, dep);

      DistortedMaster.newSlave(mSurfaceParent);

      }

    else

      {

      mPostprocess = dep;

      }

    }

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

/**

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

 *

 * @return The DistortedEffectsPostprocess contained in the Node.

 */

  public DistortedEffectsPostprocess getEffectsPostprocess()

    {

    return mPostprocess;

    }

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

/**

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

 * 

 * @return The DistortedEffects contained in the Node.

 */

  public DistortedEffects getEffects()

    {

    return mEffects;

    }

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

/**

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

 *

 * @return The DistortedInputSurface contained in the Node.

 */

  public DistortedInputSurface getSurface()

    {

    return mSurface;

    }

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

/**

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

 *

 * @return The DistortedFramebuffer contained in the Node.

 */

  public DistortedFramebuffer getFramebuffer()

    {

    return mData.mFBO;

    }

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

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

    }

  }