Distorted Android

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

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.library.main;

import android.opengl.GLES31;

import android.opengl.Matrix;

import org.distorted.library.effect.EffectQuality;

import org.distorted.library.effectqueue.EffectQueuePostprocess;

import org.distorted.library.mesh.MeshBase;

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

/**

public abstract class InternalOutputSurface extends InternalSurface implements InternalChildrenList.Parent

{

  public static final int NO_DEPTH_NO_STENCIL = 0;

  float mFOV, mDistance, mNear, mMipmap;

  float[] mProjectionMatrix;

  int mDepthStencilCreated, mDepthStencil;

  int mCurrFBO;     // internal current FBO (see DistortedLibrary.FBO_QUEUE_SIZE)

  int mWidth, mHeight;

  private static DistortedFramebuffer[] mBuffer=null; // Global buffers used for postprocessing.

  private InternalChildrenList mChildren;

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

  InternalOutputSurface(int width, int height, int createColor, int numfbos, int numcolors, int depthStencil, int fbo, int type)

    {

    super(createColor,numfbos,numcolors,type);

    mRenderWayOIT = false;

    mCurrFBO      = 0;

    mDepthStencilH = new int[numfbos];

    mRealWidth = mWidth = width;

    mProjectionMatrix = new float[16];

    mNear=  0.5f;

    mDepthStencilCreated= (depthStencil== NO_DEPTH_NO_STENCIL ? DONT_CREATE:NOT_CREATED_YET);

    mDepthStencil = depthStencil;

    mClearR = 0.0f;

    mClearStencil = 0;

    mClear = GLES31.GL_DEPTH_BUFFER_BIT | GLES31.GL_COLOR_BUFFER_BIT;

    mMipmap = 1.0f;

    mChildren = new InternalChildrenList(this);

    createProjection();

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

  private void createProjection()

    {

        float a = 2.0f*(float)Math.tan(mFOV*Math.PI/360);

        float q = mWidth*mNear;

        float left   = -q/2;

        mDistance    = mHeight/a;

        float far    = 2*mDistance-near;

        float left   = -mWidth/2.0f;

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

  private static void createPostprocessingBuffers(int width, int height, float near)

    {

    final float CLEAR_R = 1.0f;

    mBuffer = new DistortedFramebuffer[EffectQuality.LENGTH];

    float mipmap=1.0f;

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

      {

      mBuffer[j] = new DistortedFramebuffer(DistortedLibrary.FBO_QUEUE_SIZE,2,BOTH_DEPTH_STENCIL,TYPE_SYST, (int)(width*mipmap), (int)(height*mipmap) );

      mBuffer[j].mMipmap = mipmap;

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

      mipmap *= EffectQuality.MULTIPLIER;

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

    InternalRenderState.colorDepthStencilOn();

    GLES31.glClearColor(CLEAR_R, CLEAR_G, CLEAR_B, CLEAR_A);

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

      {

      for(int k = 0; k< DistortedLibrary.FBO_QUEUE_SIZE; k++)

        {

      }

    InternalRenderState.colorDepthStencilRestore();

    GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, 0);

    }

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

  static synchronized void onDestroy()

    {

    if( mBuffer!=null )

      {

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

      }

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

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

//

  private static void clonePostprocessingViewportAndProjection(InternalOutputSurface from)

    {

    if( mBuffer[0].mWidth != from.mWidth || mBuffer[0].mHeight != from.mHeight ||

      {

      InternalOutputSurface surface;

        surface = mBuffer[i];

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

        surface.mFOV    = from.mFOV;

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

        surface.createProjection();

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

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

          surface.recreate();

          }

      }

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

  private int blitWithDepth(long currTime, InternalOutputSurface buffer, int fbo)

    {

    setAsOutput(currTime);

    GLES31.glActiveTexture(GLES31.GL_TEXTURE0);

    DistortedLibrary.blitDepthPriv(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );

    GLES31.glActiveTexture(GLES31.GL_TEXTURE0);

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

    buffer.setAsOutput();

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

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

  private static void oitClear(InternalOutputSurface buffer)

    {

    int counter = DistortedLibrary.zeroOutAtomic();

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

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

  private int oitBuild(long time, InternalOutputSurface buffer, int fbo)

    {

    GLES31.glViewport(0, 0, mWidth, mHeight);

    setAsOutput(time);

    GLES31.glActiveTexture(GLES31.GL_TEXTURE0);

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

    GLES31.glActiveTexture(GLES31.GL_TEXTURE1);

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

    InternalRenderState.colorDepthStencilOn();

    DistortedLibrary.oitBuild(this, buffer.getWidthCorrection(), buffer.getHeightCorrection() );

    GLES31.glActiveTexture(GLES31.GL_TEXTURE0);

    InternalRenderState.colorDepthStencilRestore();

    return 1;

// two phases: 1. collapse the SSBO 2. blend the ssbo's color

  private int oitRender(long currTime, int fbo)

    {

    float corrW = getWidthCorrection();

    // Do the Collapse Pass only if we do have a Depth attachment.

    if( mDepthStencilH[fbo] != 0 )

      {

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

      InternalRenderState.switchOffColorDepthStencil();

      GLES31.glBindTexture(GLES31.GL_TEXTURE_2D, 0);

    setAsOutput(currTime);

    InternalRenderState.switchColorDepthOnStencilOff();

    return 1;

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

  private void clear()

    {

    InternalRenderState.colorDepthStencilOn();

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

    InternalRenderState.colorDepthStencilRestore();

    }

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

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

// Render all children, one by one. If there are no postprocessing effects, just render to THIS.

// to a whole buffer (lastQueue.postprocess) and merge it (this.oitBuild or blitWithDepth - depending

  int renderChildren(long time, int numChildren, InternalChildrenList children, int fbo, boolean oit)

    {

    int numRenders=0, bucketChange=0;

    DistortedNode child;

    DistortedFramebuffer buffer=null;

    EffectQueuePostprocess lastQueue=null, currQueue;

    long lastBucket=0, currBucket;

    boolean renderDirectly=false;

    setCurrFBO(fbo);

      for (int i=0; i<EffectQuality.LENGTH; i++) mBuffer[i].setCurrFBO(fbo);

      }

    if( oit && numChildren>0 )

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

      {

      child = children.getChild(i);

      currQueue = (EffectQueuePostprocess)child.getEffects().getQueues()[3];

      currBucket= currQueue.getID();

      if( currBucket==0 )

        setAsOutput(time);

          numRenders += child.drawOIT(time, this);

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

          numRenders += child.draw(time, this);

          }

        }

      else

        if( mBuffer==null )

          for (int j=0; j<EffectQuality.LENGTH; j++) mBuffer[j].setCurrFBO(fbo);

          }

        if( lastBucket!=currBucket )

          {

          if( lastBucket==0 )

            clonePostprocessingViewportAndProjection(this);

            }

            {

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

            numRenders += lastQueue.postprocess(buffer);

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

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

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

              }

            buffer.clearBuffer(fbo);

            }

          buffer= mBuffer[currQueue.getQuality()];

          bucketChange= i;

          renderDirectly = currQueue.getRender();

          }

        if( renderDirectly )

          buffer.setAsOutput(time);

          }

        if( i==numChildren-1 )

          {

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

          numRenders += currQueue.postprocess(buffer);

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

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

            buffer.clearBuffer(fbo);

            }

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

            }

          }

        } // end else (postprocessed child)

      lastQueue = currQueue;

      } // end main for loop

    if( oit && numChildren>0 )

    return numRenders;

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

/**

 * Not part of the public API.

 *

  public void adjustIsomorphism() { }

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

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

  void clearBuffer(int fbo)

    {

    InternalRenderState.colorDepthStencilOn();

    InternalRenderState.colorDepthStencilRestore();

    }

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

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

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

/**

 * Draws all the attached children to this OutputSurface's 0th FBO.

 * <p>

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

 * @return Number of objects rendered.

 */

  public int render(long time)

    {

    {

    InternalMaster.toDo();

    toDo();

    InternalRenderState.reset();

    int numRenders=0, numChildren = mChildren.getNumChildren();

    DistortedNode node;

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

      {

      node = mChildren.getChild(i);

      }

    numRenders += renderChildren(time,numChildren,mChildren,fbo, mRenderWayOIT);

    return numRenders;

    }

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

    GLES31.glBindFramebuffer(GLES31.GL_FRAMEBUFFER, mFBOH[mCurrFBO]);

    }

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

 * <p>

 *