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

 * This is not really part of the public API.

 *

 * @y.exclude

 */

  public static final int DEPTH_NO_STENCIL    = 1;

  public static final int BOTH_DEPTH_STENCIL  = 2;

  static final float DEFAULT_NEAR=  0.1f;

  private long[] mTime;

  private float mClearR, mClearG, mClearB, mClearA, mClearDepth;

  private int mClear, mClearStencil;

  private boolean mRenderWayOIT;

  // Global buffers used for postprocessing

  float mDistance, mNear, mMipmap;

  int[] mDepthStencilH, mFBOH;

  int mRealWidth;   // the Surface can be backed up by a texture larger than the viewport we have to it.

  int mRealHeight;  // mWidth,mHeight are the sizes of the Viewport, those - sizes of the backing up texture.

    mRealHeight= mHeight= height;

    mNear= DEFAULT_NEAR;

    mClearG = 0.0f;

    mClearB = 0.0f;

    mClearA = 0.0f;

    mClearDepth = 1.0f;

    mTime = new long[10]; // when trying to read from 'null array' mFBOH. Probably sometimes a

                          // a Framebuffer gets created in the wrong moment, just after we did a

                          // round of create(), but before we start rendering.

                          // Create an empty FBO and Time here so that setAsOutput() is always safe to call.

    }

  void allocateStuffDependantOnNumFBOS()

    {

    if( mNumFBOs>0 )

      {

      mDepthStencilH   = new int[mNumFBOs];

      mDepthStencilH[0]= 0;

      mFBOH   = new int[mNumFBOs];

      mFBOH[0]= mTmpFBO;

      mTime = new long[mNumFBOs];

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

      }

    }

    if( mWidth>0 && mHeight>1 )

      {

      if( mFOV>0.0f )  // perspective projection

        {

        float c = mHeight*mNear;

        float right  = +q/2;

        float bottom = -c/2;

        float top    = +c/2;

        float near   =  c/a;

      else             // parallel projection

        {

        float right  = +mWidth/2.0f;

        float bottom = -mHeight/2.0f;

        float top    = +mHeight/2.0f;

        float near   = mWidth+mHeight-mHeight*(1.0f-mNear);

        mDistance    = mWidth+mHeight;

        float far    = mWidth+mHeight+mHeight*(1.0f-mNear);

      }

    }

    final float CLEAR_G = 1.0f;

    final float CLEAR_B = 1.0f;

    final float CLEAR_A = 0.0f;

    final float CLEAR_D = 1.0f;

    final int   CLEAR_S = 0;

    mBuffer[quality].mNear = near;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )

    mBuffer[quality].glClearColor(CLEAR_R, CLEAR_G, CLEAR_B, CLEAR_A);

    GLES30.glClearDepthf(CLEAR_D);

    GLES30.glClearStencil(CLEAR_S);

      GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, mBuffer[quality].mColorH[2*k+1], 0);

      GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT | GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_STENCIL_BUFFER_BIT);

      GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, mBuffer[quality].mColorH[2*k  ], 0);

      GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);

      if( mBuffer[j]!=null )

        }

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, buffer.mColorH[2*fbo]);

    GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, buffer.mDepthStencilH[fbo]);

    GLES30.glStencilMask(0x00);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);

    GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);

    // clear buffers

    GLES30.glDepthMask(true);

    GLES30.glColorMask(true,true,true,true);

    GLES30.glClearColor(buffer.mClearR,buffer.mClearG,buffer.mClearB,buffer.mClearA);

    GLES30.glClearDepthf(buffer.mClearDepth);

    GLES30.glClearStencil(buffer.mClearStencil);

    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT|GLES30.GL_DEPTH_BUFFER_BIT|GLES30.GL_STENCIL_BUFFER_BIT);

    GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, buffer.mColorH[2*fbo  ], 0);

    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);

    return 1;

    }

    DistortedLibrary.oitClear(buffer,counter);

    }

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, buffer.mColorH[2*fbo]);

    GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, buffer.mDepthStencilH[fbo]);

    InternalRenderState.enableDepthTest();

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);

    GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);

    InternalRenderState.restoreDepthTest();

    }

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

    float corrH = getHeightCorrection();

    // Otherwise there's no point (in fact we then would create a feedback loop!)

      GLES30.glActiveTexture(GLES30.GL_TEXTURE1);

      GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mDepthStencilH[fbo]);

      DistortedLibrary.oitCollapse(this, corrW, corrH);

    DistortedLibrary.oitRender(this, corrW, corrH);

    InternalRenderState.restoreColorDepthStencil();

    }

    GLES30.glClearDepthf(mClearDepth);

    GLES30.glClearStencil(mClearStencil);

    GLES30.glClear(mClear);

  void setCurrFBO(int fbo)

    {

    mCurrFBO = fbo;

    }

// Render all children from the current bucket to the buffer, apply the postprocessing once to the

// whole buffer (queue.postprocess) and merge it to 'this' (oitBuild or blitWithDepth depending on

// the type of rendering)

  private int accumulateAndBlit(EffectQueuePostprocess queue, InternalChildrenList children, DistortedFramebuffer buffer,

                                int begIndex, int endIndex, boolean isFinal, long time, int fbo, boolean oit )

    {

    int numRenders = 0;

    for(int j=begIndex; j<endIndex; j++)

       {

       DistortedNode node = children.getChild(j);

       if( node.getSurface().setAsInput() )

         {

         buffer.setAsOutput();

         numRenders += queue.preprocess( buffer, node, buffer.mDistance, buffer.mMipmap, buffer.mProjectionMatrix );

         }

       }

    numRenders += queue.postprocess(buffer);

    if( oit )

      {

      numRenders += oitBuild(time, buffer, fbo);

      GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT | GLES31.GL_ATOMIC_COUNTER_BARRIER_BIT);

      buffer.clearBuffer(fbo);

      }

    else

      {

      numRenders += blitWithDepth(time, buffer, fbo);

      if( !isFinal ) buffer.clearBuffer(fbo);

      }

    return numRenders;

    }

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

  private int renderChildToThisOrToBuffer(DistortedNode child, DistortedFramebuffer buffer, long time, boolean oit, boolean toThis)

    {

    int numRenders;

    if( toThis )

      {

      setAsOutput(time);

      if( oit )

        {

        numRenders = child.drawOIT(time, this);

        GLES31.glMemoryBarrier(GLES31.GL_SHADER_STORAGE_BARRIER_BIT | GLES31.GL_ATOMIC_COUNTER_BARRIER_BIT);

        }

      else

        {

        numRenders = child.draw(time, this);

        }

      }

    else

      {

      buffer.setAsOutput(time);

      numRenders = child.drawNoBlend(time, buffer);

      }

    return numRenders;

    }

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

// The postprocessing buffers mBuffer[] are generally speaking too large (there's just one static

// set of them) so before we use them for output, we need to adjust the Viewport as if they were

// smaller. That takes care of outputting pixels to them. When we use them as input, we have to

// adjust the texture coords - see the get{Width|Height}Correction functions.

//

// Also, adjust the Buffers so their Projection is the same like the surface we are supposed to be

// rendering to.

  private void clonePostprocessingViewportAndProjection(InternalOutputSurface surface, InternalOutputSurface from)

    {

    if( surface.mWidth != from.mWidth || surface.mHeight != from.mHeight ||

        surface.mFOV   != from.mFOV   || surface.mNear   != from.mNear    )

      {

      surface.mWidth  = (int)(from.mWidth *surface.mMipmap);

      surface.mHeight = (int)(from.mHeight*surface.mMipmap);

      surface.mFOV    = from.mFOV;

      surface.mNear   = from.mNear;  // Near plane is independent of the mipmap level

      surface.createProjection();

      int maxw = Math.max(surface.mWidth , surface.mRealWidth );

      int maxh = Math.max(surface.mHeight, surface.mRealHeight);

      if (maxw > surface.mRealWidth || maxh > surface.mRealHeight)

        {

        surface.mRealWidth = maxw;

        surface.mRealHeight = maxh;

        surface.recreate();

        surface.create();

        }

      }

    }

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

  private DistortedFramebuffer initializeBuffer(EffectQueuePostprocess queue, int fbo )

    {

    int currQuality = queue.getQuality();

    if( mBuffer[currQuality]==null ) createPostprocessingBuffers(currQuality, mWidth, mHeight, mNear);

    mBuffer[currQuality].setCurrFBO(fbo);

    if( !mBufferInitialized[currQuality] )

      {

      mBufferInitialized[currQuality] = true;

      clonePostprocessingViewportAndProjection(mBuffer[currQuality],this);

      }

    return mBuffer[currQuality];

    }

// Otherwise, render to a buffer and on each change of Postprocessing Bucket, apply the postprocessing

// on the type of rendering)

    for(int i=0; i<EffectQuality.LENGTH; i++) mBufferInitialized[i]=false;

        if( lastBucket!=0 ) numRenders += accumulateAndBlit(lastQueue,children,buffer,bucketChange,i,false,time,fbo,oit);

        bucketChange= i;

        toThis = currQueue.getRenderDirectly();

      if( currBucket!=0 && i==numChildren-1 ) numRenders += accumulateAndBlit(currQueue,children,buffer,bucketChange,numChildren,true,time,fbo,oit);

      lastBucket= currBucket;

    }

 * @y.exclude

 */

/**

 * Not part of the Public API.

 *

 * @y.exclude

 */

  public float getWidthCorrection()

    {

    return (float)mWidth/mRealWidth;

    }

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

/**

 * Not part of the Public API.

 *

 * @y.exclude

 */

  public float getHeightCorrection()

    {

    return (float)mHeight/mRealHeight;

    }

    GLES30.glClearDepthf(mClearDepth);

    GLES30.glClearStencil(mClearStencil);

    GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, mColorH[2*fbo+1], 0);

    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT|GLES30.GL_DEPTH_BUFFER_BIT|GLES30.GL_STENCIL_BUFFER_BIT);

    GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, mColorH[2*fbo  ], 0);

    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);

  void setAsOutput(long time)

    {

    if( mTime[mCurrFBO]!=time )

      {

      mTime[mCurrFBO] = time;

      clear();

      }

    }

// PUBLIC API

 * Must be called from a thread holding OpenGL Context.

 *

    return render(time,0);

    }

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

/**

 * Draws all the attached children to this OutputSurface.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param time Current time, in milliseconds. This will be passed to all the Effects stored in the children Nodes.

 * @param fbo The surface can have many FBOs backing it up - render this to FBO number 'fbo'.

 * @return Number of objects rendered.

 */

  public int render(long time, int fbo)

    long oldBucket=0, newBucket;

      newBucket = node.getBucket();

      numRenders += node.renderRecursive(time);

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

      else oldBucket=newBucket;

/**

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

 */

  public void debug()

    {

    int numChildren = mChildren.getNumChildren();

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

      {

      DistortedNode node = mChildren.getChild(i);

      node.debug(0);

      }

    }

/**

 * Bind this Surface as a Framebuffer we can render to.

 * <p>

 * This version does not attempt to clear anything.

 */

  public void setAsOutput()

    {

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

/**

 * Return the Near plane of the Projection included in the Surface.

 *

 * @return the Near plane.

 */

  public float getNear()

    {

    return mNear;

    }

/**

 * Set mipmap level.

 * <p>

 * Trick for speeding up your renders - one can create a pyramid of OutputSurface objects, each next

 * one some constant FACTOR smaller than the previous (0.5 is the common value), then set the Mipmap

 * Level of the i-th object to be FACTOR^i (we start counting from 0). When rendering any scene into

 * such prepared OutputSurface, the library will make sure to scale any Effects used so that the end

 * scene will end up looking identical no matter which object we render to. Identical, that is, except