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 android.opengl.GLES30;

import android.opengl.Matrix;

import java.util.ArrayList;

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

abstract class DistortedOutputSurface extends DistortedSurface implements DistortedAttacheable

{

  private ArrayList<DistortedNode> mChildren;

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

  private long mTime;

  private float mFOV;

  int mWidth,mHeight,mDepth;

  float mDistance, mNear;

  float[] mProjectionMatrix;

  int mDepthCreated;

  int[] mDepthH = new int[1];

  int[] mFBOH   = new int[1];

  private float mClearR, mClearG, mClearB, mClearA;

  private float mClearDepth;

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

  abstract DistortedFramebuffer getBuffer();

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

  DistortedOutputSurface(int width, int height, int createColor, int createDepth, int fbo, int type)

    {

    super(width,height,createColor,type);

    mProjectionMatrix = new float[16];

    mWidth = width;

    mHeight= height;

    mFOV = 60.0f;

    mNear=  0.5f;

    mDepthCreated= createDepth;

    mFBOH[0]     = fbo;

    mDepthH[0]   = 0;

    mTime = 0;

    mClearR = 0.0f;

    mClearG = 0.0f;

    mClearB = 0.0f;

    mClearA = 0.0f;

    mClearDepth = 1.0f;

    createProjection();

    }

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

  void createProjection()

    {

    if( mWidth>0 && mHeight>1 )

      {

      if( mFOV>0.0f )  // perspective projection

        {

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

        float q = mWidth*mNear;

        float c = mHeight*mNear;

        float left   = -q/2;

        float right  = +q/2;

        float bottom = -c/2;

        float top    = +c/2;

        float near   =  c/a;

        mDistance    = mHeight/a;

        float far    = 2*mDistance-near;

        mDepth       = (int)((far-near)/2);

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

        }

      else             // parallel projection

        {

        float left   = -mWidth /2.0f;

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

        mDepth       = (int)((far-near)/2);

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

        }

      }

    }

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

  int renderChildren(long time, int num, ArrayList<DistortedNode> children)

    {

    int numRenders = 0;

    DistortedNode child;

    DistortedFramebuffer fbo;

    DistortedOutputSurface surface;

    // 1. Render all children that have postprocessing effects to their own buffer FBOs

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

      {

      child = children.get(i);

      fbo   = child.getPostprocessingBuffer();

      if( fbo!=null )

        {

        fbo.resizeFast(mWidth,mHeight);

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

        }

      }

    // 2. If we have rendered anything so far, and we are a Screen, then render to an

    //    intermediate FBO instead.

    surface = this;//numRenders>0 ? getBuffer() : this;

    // 3. Render all children without postprocessing effects to buffer

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

      {

      child = children.get(i);

      fbo   = child.getPostprocessingBuffer();

      if( fbo==null )

        {

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

        }

      }

    // 4. For all postprocessing fbo,

    //       postprocess fbo

    //       merge to buffer

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

      {

      numRenders += children.get(i).postprocess(time,surface);

      }

    // 5. finally blit to this if we have to

    if( surface!=this && ((DistortedFramebuffer)surface).setAsInput() )

      {

      numRenders++;

      DistortedEffects.blitPriv(this);

      }

    return numRenders;

    }

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

// PUBLIC API

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

/**

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

 * @return Number of objects rendered.

 */

  public int render(long time)

    {

    // change tree topology (attach and detach children)

/*

    boolean changed =

*/

    DistortedAttachDaemon.toDo();

/*

    // debugging only

    if( changed )

      {

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

        {

        mChildren.get(i).debug(0);

        }

      DistortedNode.debugMap();

      }

*/

    // create and delete all underlying OpenGL resources

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

    toDo();

/*

    // debugging only

    if( changed )

      {

      DistortedSurface.debugLists();

      }

*/

    // mark OpenGL state as unknown

    DistortedRenderState.reset();

    int numRenders=0;

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

      {

      numRenders += mChildren.get(i).renderRecursive(time);

      }

    setAsOutput(time);

    numRenders += renderChildren(time,mNumChildren,mChildren);

    return numRenders;

    }

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

/**

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

 */

  public void setAsOutput(long time)

    {

    GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, mFBOH[0]);

    if( mTime!=time )

      {

      mTime = time;

      DistortedRenderState.colorDepthOn();

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

      GLES30.glClearDepthf(mClearDepth);

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

      }

    }

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

/**

 * Set the (R,G,B,A) values of GLES30.glClearColor() to set up color with which to clear

 * this Surface before each render.

 *

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

    }

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

/**

 * Set the Depth value of GLES30.glClearDepthf() to set up depth with which to clear

 * the Depth buffer of Surface before each render.

 *

 * @param d the Depth. Default: 1.0f

 */

  public void glClearDepthf(float d)

    {

    mClearDepth = d;

    }

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

/**

 * Create new Projection matrix.

 *

 * @param fov Vertical 'field of view' of the Projection frustrum (in degrees).

 *            Valid values: 0<=fov<180. FOV==0 means 'parallel projection'.

 * @param near Distance between the screen plane and the near plane.

 *             Valid vaules: 0<near<1. When near==0, the Near Plane is exactly at the tip of the

 *             pyramid. When near==1 (illegal!) the near plane is equivalent to the screen plane.

 */

  public void setProjection(float fov, float near)

    {

    if( fov < 180.0f && fov >=0.0f )

      {

      mFOV = fov;

      }

    if( near<   1.0f && near> 0.0f )

      {

      mNear= near;

      }

    else if( near<=0.0f )

      {

      mNear = 0.01f;

      }

    else if( near>=1.0f )

      {

      mNear=0.99f;

      }

    createProjection();

    }

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

/**

 * Resize the underlying Framebuffer.

 * <p>

 * This method can be safely called mid-render as it doesn't interfere with rendering.

 *

 * @param width The new width.

 * @param height The new height.

 */

  public void resize(int width, int height)

    {

    if( mWidth!=width || mHeight!=height )

      {

      mWidth = width;

      mHeight= height;

      mSizeX = width;

      mSizeY = height;

      createProjection();

      if( mColorCreated==CREATED )

        {

        markForCreation();

        recreate();

        }

      }

    }

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

/**

 * Create a new DEPTH buffer and attach it or (param=false) detach an existing DEPTH attachment and recreate it.

 *

 * @param enable <bold>true</bold> if we want to attach a new DEPTH buffer to the FBO.<br>

 *               <bold>false</bold> if we want to detach the DEPTH attachment.

 */

  public void enableDepth(boolean enable)

    {

    if( enable && mDepthCreated==DONT_CREATE )

      {

      mDepthCreated = NOT_CREATED_YET;

      markForCreation();

      }

    if( !enable && mDepthCreated!=DONT_CREATE )

      {

      mDepthCreated = DONT_CREATE;

      markForCreation();

      }

    }

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

/**

 * Return true if the Surface contains a DEPTH attachment.

 *

 * @return <bold>true</bold> if the FBO contains a DEPTH attachment.

 */

  public boolean hasDepth()

    {

    return mDepthCreated==CREATED;

    }

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

/**

 * Adds a new child to the last position in the list of our Surface's children.

 * <p>

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 * DistortedAttachDeamon (by calling attachNow())

 *

 * @param node The new Node to add.

 */

  public void attach(DistortedNode node)

    {

    DistortedAttachDaemon.attach(this,node);

    }

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

/**

 * Adds a new child to the last position in the list of our Surface's children.

 * <p>

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 * DistortedAttachDeamon (by calling attachNow())

 *

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

    DistortedAttachDaemon.attach(this,node);

    return node;

    }

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

/**

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

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

 * Java has no multiple inheritance.

 *

 * @y.exclude

 * @param node new Node to add.

 */

  public void attachNow(DistortedNode node)

    {

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

    mChildren.add(node);

    mNumChildren++;

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Surface.

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

 * DistortedAttachDeamon (by calling detachNow())

 *

 * @param effects DistortedEffects to remove.

 */

  public void detach(DistortedEffects effects)

    {

    long id = effects.getID();

    DistortedNode node;

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

      {

      node = mChildren.get(i);

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

        {

        DistortedAttachDaemon.detach(this,node);

        break;

        }

      }

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Surface.

 * <p>

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 * DistortedAttachDeamon (by calling detachNow())

 *

 * @param node The Node to remove.

 */

  public void detach(DistortedNode node)

    {

    DistortedAttachDaemon.detach(this,node);

    }

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

/**

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

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

 * Java has no multiple inheritance.

 *

 * @y.exclude

 * @param node The Node to remove.

 */

  public void detachNow(DistortedNode node)

    {

    if( mNumChildren>0 && mChildren.remove(node) )

      {

      mNumChildren--;

      }

    }

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

/**

 * Removes all children Nodes.

 * <p>

 * We cannot do this mid-render - actual attachment will be done just before the next render, by the

 * DistortedAttachDeamon (by calling detachAllNow())

 */

  public void detachAll()

    {

    DistortedAttachDaemon.detachAll(this);

    }

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

/**

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

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

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void detachAllNow()

    {

    if( mNumChildren>0 )

      {

      mNumChildren = 0;

      mChildren.clear();

      }

    }

}