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 static int mRender = 0;

  private ArrayList<DistortedNode> mChildren;

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

  private float mX, mY, mFOV;

  int mWidth,mHeight,mDepth;

  float mDistance;

  float[] mProjectionMatrix;

  int mDepthCreated;

  int[] mDepthH = new int[1];

  int[] mFBOH   = new int[1];

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

  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;

    mX   =  0.0f;

    mY   =  0.0f;

    mDepthCreated= createDepth;

    mFBOH[0]     = fbo;

    mDepthH[0]   = 0;

    createProjection();

    }

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

  void createProjection()

    {

    if( mWidth>0 && mHeight>1 )

      {

      if( mFOV>0.0f )  // perspective projection

        {

        float left   = (-mX-mWidth /2.0f)/mHeight;

        float right  = (-mX+mWidth /2.0f)/mHeight;

        float bottom = (-mY-mHeight/2.0f)/mHeight;

        float top    = (-mY+mHeight/2.0f)/mHeight;

        float near   = (top-bottom) / (2.0f*(float)Math.tan(mFOV*Math.PI/360));

        mDistance    = mHeight*near/(top-bottom);

        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   = -mX-mWidth /2.0f;

        float right  = -mX+mWidth /2.0f;

        float bottom = -mY-mHeight/2.0f;

        float top    = -mY+mHeight/2.0f;

        float near   = (mWidth+mHeight)/2;

        mDistance    = 2*near;

        float far    = 3*near;

        mDepth       = (int)near;

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

        }

      }

    }

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

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

    {

    mRender++;

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

      }

*/

    GLES30.glDepthFunc(GLES30.GL_LEQUAL);

    GLES30.glEnable(GLES30.GL_BLEND);

    GLES30.glBlendFunc(GLES30.GL_SRC_ALPHA, GLES30.GL_ONE_MINUS_SRC_ALPHA);

    GLES30.glDisable(GLES30.GL_CULL_FACE);

    int numRenders = 0;

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

      {

      numRenders += mChildren.get(i).drawRecursive(mRender,time,this);

      }

    return numRenders;

    }

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

/**

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

 */

  public void setAsOutput()

    {

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

    if( mDepthCreated==CREATED )

      {

      GLES30.glEnable(GLES30.GL_DEPTH_TEST);

      GLES30.glDepthMask(true);

      }

    else

      {

      GLES30.glDisable(GLES30.GL_DEPTH_TEST);

      GLES30.glDepthMask(false);

      }

    }

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

/**

 * Create new Projection matrix.

 *

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

 * @param x X-coordinate of the point at which our camera looks at. 0 is the center.

 * @param y Y-coordinate of the point at which our camera looks at. 0 is the center.

 */

  public void setProjection(float fov, float x, float y)

    {

    mFOV = fov;

    mX = x;

    mY = y;

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

      }

    }

}