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

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

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

 * This is not really part of the public API.

 *

 * @y.exclude

 */

public abstract class DistortedOutputSurface extends DistortedSurface implements DistortedMaster.Slave

 * Do not create DEPTH or STENCIL attachment

 */

 * Create DEPTH, but not STENCIL

 */

 * Create both DEPTH and STENCIL

 */

  private static final int DETACH = 1;

  private static final int DETALL = 2;

  private static final int SORT   = 3;

  private int mNumChildren;   // ==mChildren.length(), but we only create mChildren if the first one gets added

    {

    int type;

    DistortedNode node;

      type = t;

      node = n;

      }

    }

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

  float mDistance, mNear;

  int mDepthStencil;

  int[] mDepthStencilH = new int[1];

  int[] mFBOH          = new int[1];

  private float mClearDepth;

  int mRealHeight;  // larger than the viewport we have to it.

                    // mWidth,mHeight are the sizes of the Viewport, those -

                    // sizes of the backing up texture.

    mRealHeight= height;

    mFOV = 60.0f;

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

        }

      }

    }

    float mipmap=1.0f;

      mBuffer[j].glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

      }

    DistortedObject.toDo(); // create the FBOs immediately. This is safe as we must be holding the OpenGL context now.

    GLES31.glDepthMask(true);

    GLES31.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

    GLES31.glClearStencil(0);

      GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT);

    }

      mBuffer[j] = null;

      }

    mBufferOIT = null;

// set of them) so before we use them for output, we need to adjust the Vieport 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.

      for(int i=0; i<EffectQuality.LENGTH; i++)

        {

        surface = mBuffer[i];

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

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

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

        int maxw = surface.mWidth  > surface.mRealWidth  ? surface.mWidth  : surface.mRealWidth;

        int maxh = surface.mHeight > surface.mRealHeight ? surface.mHeight : surface.mRealHeight;

          {

          surface.mRealWidth = maxw;

          surface.mRealHeight = maxh;

          surface.create();

        }

    }

  private static void oitClear(DistortedOutputSurface buffer)

    {

    if( mBufferOIT==null )

      {

      mBufferOIT = new DistortedFramebuffer(1, BOTH_DEPTH_STENCIL, TYPE_SYST, buffer.mWidth, buffer.mHeight);

      mBufferOIT.mMipmap = 1.0f;

      mBufferOIT.mNear = buffer.mNear;  // copy mNear as well (for blitting- see PostprocessEffect.apply() )

      mBufferOIT.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

      DistortedObject.toDo(); // create the FBOs immediately. This is safe as we must be holding the OpenGL context now.

      }

    if( mBufferOIT.mWidth != buffer.mWidth || mBufferOIT.mHeight != buffer.mHeight )

      {

      mBufferOIT.mWidth  = (int)(buffer.mWidth *mBufferOIT.mMipmap);

      mBufferOIT.mHeight = (int)(buffer.mHeight*mBufferOIT.mMipmap);

      mBufferOIT.mNear   = buffer.mNear;  // Near plane is independent of the mipmap level

      //android.util.Log.e("surface", "viewport "+i+" to ("+from.mWidth+"x"+from.mHeight+")");

      mBufferOIT.createProjection();

      int maxw = mBufferOIT.mWidth  > mBufferOIT.mRealWidth  ? mBufferOIT.mWidth  : mBufferOIT.mRealWidth;

      int maxh = mBufferOIT.mHeight > mBufferOIT.mRealHeight ? mBufferOIT.mHeight : mBufferOIT.mRealHeight;

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

        {

        mBufferOIT.mRealWidth = maxw;

        mBufferOIT.mRealHeight = maxh;

        mBufferOIT.recreate();

        mBufferOIT.create();

        }

      }

    if( mBufferOIT.mNear != buffer.mNear || mBufferOIT.mFOV != buffer.mFOV )

      {

      mBufferOIT.mNear = buffer.mNear;

      mBufferOIT.mFOV  = buffer.mFOV;

      mBufferOIT.createProjection();

      }

    GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);

    DistortedRenderState.colorDepthStencilOn();

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

    GLES31.glClearDepthf(buffer.mClearDepth);

    GLES31.glClearStencil(buffer.mClearStencil);

    GLES31.glClear(buffer.mClear);

    DistortedRenderState.colorDepthStencilRestore();

    DistortedEffects.zeroOutAtomic();

    DistortedEffects.oitClear(buffer);

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

    }

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mColorH[0]);

    GLES31.glActiveTexture(GLES31.GL_TEXTURE1);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mDepthStencilH[0]);

    //GLES31.glStencilMask(0x00);

    DistortedRenderState.colorDepthStencilOn();

    DistortedRenderState.enableDepthTest();

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);

    GLES31.glActiveTexture(GLES31.GL_TEXTURE1);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);

    DistortedRenderState.restoreDepthTest();

    }

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

      {

      android.util.Log.e("surface", "feedback loop in oitRender!");

      return 0;

      }

    setAsOutput(currTime);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mColorH[0]);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, buffer.mDepthStencilH[0]);

    GLES31.glStencilMask(0x00);

    GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);

    return 1;

    }

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

    GLES31.glDepthMask(true);

    GLES31.glColorMask(true,true,true,true);

    GLES31.glClearStencil(0);

    buffer.setAsOutput();

    for(int i=buffer.mNumColors-2; i>=0; i--)

      {

      GLES31.glFramebufferTexture2D(GLES31.GL_FRAMEBUFFER, GLES31.GL_COLOR_ATTACHMENT0, GLES31.GL_TEXTURE_2D, buffer.mColorH[i], 0);

      GLES31.glClear(GLES31.GL_COLOR_BUFFER_BIT);

      }

  void clear()

    {

    DistortedRenderState.colorDepthStencilOn();

    GLES31.glClearColor(mClearR, mClearG, mClearB, mClearA);

    GLES31.glClearDepthf(mClearDepth);

    GLES31.glClearStencil(mClearStencil);

    GLES31.glClear(mClear);

    DistortedRenderState.colorDepthStencilRestore();

    }

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

      currBucket= currQueue.getID();

        {

        GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mBufferOIT.mFBOH[0]);

        numRenders += child1.draw(time, mBufferOIT);

        //setAsOutput(time);

        //numRenders += child1.draw(time,this);

        }

        {

            {

          else

            for(int j=bucketChange; j<i; j++)

              {

          quality         = currQueue.getQuality();

          bucketChange    = i;

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

      lastBucket= currBucket;

    if( currBucket==0 ) // there was no postprocessing - we need to merge the main buffer

      {

      numRenders += oitRender(time,mBufferOIT);

    }

/**

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

    }

// PUBLIC API

 * Must be called from a thread holding OpenGL Context.

 *

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

        {

    // Watch out: FIRST change topology, only then deal

    // with OpenGL resources. That's because changing Tree

    // can result in additional Framebuffers that would need

    // to be created immediately, before the calls to drawRecursive()

    boolean changed2 =

*/

    DistortedRenderState.reset();

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

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

 * @param time Present time, in milliseconds. The point: looking at this param the library can figure

 *             out if this is the first time during present frame that this FBO is being set as output.

 *             If so, the library, in addition to binding the Surface for output, also clears the

 *             Surface's color and depth attachments.

    if( mTime!=time )

      {

      mTime = time;

/**

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

    mClearB = b;

    mClearA = a;

    }

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

/**

 * the Depth buffer of our Surface at the beginning of each frame.

 * @param d the Depth. Default: 1.0f

 */

  public void glClearDepthf(float d)

    {

    mClearDepth = d;

    }

/**

 * Uses glClearStencil() to set up a value with which to clear the

 * Stencil buffer of our Surface at the beginning of each frame.

 *

 * @param s the Stencil. Default: 0

 */

  public void glClearStencil(int s)

    {

    mClearStencil = s;

    }

/**

 * Which buffers to Clear at the beginning of each frame?

 * <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: GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT.

 *

 * @param mask bitwise OR of BUFFER_BITs to clear.

 */

  public void glClear(int mask)