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

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

  private InternalChildrenList mChildren;

  // Global buffers used for postprocessing

  private static DistortedFramebuffer[] mBuffer= new DistortedFramebuffer[EffectQuality.LENGTH];

  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.

    mFBOH          = new int[numfbos];

    mTime = new long[numfbos];

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

    mRealHeight= mHeight= height;

    mNear= DEFAULT_NEAR;

    mFBOH[0]         = fbo;

    mDepthStencilH[0]= 0;

    mClearG = 0.0f;

    mClearB = 0.0f;

    mClearA = 0.0f;

    mClearDepth = 1.0f;

    }

    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;

        Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);

        }

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

        Matrix.orthoM(mProjectionMatrix, 0, left, right, bottom, top, near, far);

        }

      }

    }

    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].mMipmap = mipmap;

    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 )

        }

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

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

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

      surface.mFOV    = from.mFOV;

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

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

        {

        surface.mRealWidth = maxw;

        surface.mRealHeight = maxh;

        surface.create();

    }

    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;

    }

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

// on the type of rendering)

      {

      oitClear(this);

      }

        {

        if( oit )

          {

          }

        else

          {

        {

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

        mBuffer[currQuality].setCurrFBO(fbo);

            {

          else

              {

              DistortedNode node = children.getChild(j);

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

                {

                buffer.setAsOutput();

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

                }

              }

            if( oit )

              {

              }

            else

              {

          {

          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

          {

          child.drawNoBlend(time, buffer);

            {

            DistortedNode node = children.getChild(j);

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

              {

              buffer.setAsOutput();

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

              }

            }

          if( oit )

            {

          else

            {

      lastBucket= currBucket;

      {

      numRenders += oitRender(time, fbo);  // merge the OIT linked list

      }

    }

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

/**

 * 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

 * for the loss of quality and gain in speed associated with rendering to a smaller Surface.

 * Example: if you create two FBOs, one 1000x1000 and another 500x500 in size, and set the second one

 * mipmap to 0.5 (the first one's is 1.0 by default), define Effects to be a single move by (100,100),

 * and render a skinned Mesh into both FBO, the end result will look proportionally the same, because

 * in the second case the move vector (100,100) will be auto-scaled to (50,50).

 * @param mipmap The mipmap level. Acceptable range: 0<mipmap<infinity, although mipmap>1

 *               does not make any sense (that would result in loss of speed and no gain in quality)

 */

  public void setMipmap(float mipmap)

    {

    mMipmap = mipmap;

    }

/**

 * @param r the Red component. Default: 0.0f

 * @param g the Green component. Default: 0.0f

 * @param b the Blue component. Default: 0.0f

 * @param a the Alpha component. Default: 0.0f

 */

  public void glClearColor(float r, float g, float b, float a)

    {

    mClearR = r;

    mClearG = g;