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.Iterator;

import java.util.LinkedList;

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

/**

 * Class which represents a OpenGL Framebuffer object.

 * <p>

 * User is able to create either Framebuffers from objects already constructed outside

 * of the library (the first constructor; primary use case: the screen) or an offscreen

 * FBOs.

 * <p>

 * Keep all objects created in a static LinkedList. The point: we need to be able to mark

 * Framebuffers for deletion, and delete all marked objects later at a convenient time (that's

 * because we can only delete from a thread that holds the OpenGL context so here we provide a

 * framework where one is able to mark for deletion at any time and actual deletion takes place

 * on the next render).

 */

public class DistortedFramebuffer extends DistortedRenderable

  {

  private static boolean mListMarked = false;

  private static LinkedList<DistortedFramebuffer> mList = new LinkedList<>();

  private int[] mDepthH = new int[1];

  private int[] mFBOH   = new int[1];

  private boolean mMarked;

  private boolean mDepthEnabled;

  // Projection stuff

  private float mX, mY, mFOV;

  int mWidth,mHeight,mDepth;

  float mDistance;

  float[] mProjectionMatrix;

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

// Must be called from a thread holding OpenGL Context

  void create()

    {

    if( mColorH[0]==NOT_CREATED_YET )

      {

      GLES30.glGenTextures(1, mColorH, 0);

      GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mColorH[0]);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_WRAP_S, GLES30.GL_REPEAT);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_WRAP_T, GLES30.GL_REPEAT);

      GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_NEAREST);

      GLES30.glTexParameterf(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);

      GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_RGBA, mSizeX, mSizeY, 0, GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE, null);

      GLES30.glGenFramebuffers(1, mFBOH, 0);

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

      GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_COLOR_ATTACHMENT0, GLES30.GL_TEXTURE_2D, mColorH[0], 0);

      checkStatus("color");

      }

    if( mDepthEnabled && mDepthH[0]==NOT_CREATED_YET ) // we need to create a new DEPTH attachment

      {

      GLES30.glGenTextures(1, mDepthH, 0);

      GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mDepthH[0]);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_WRAP_S, GLES30.GL_REPEAT);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_WRAP_T, GLES30.GL_REPEAT);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_NEAREST);

      GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_NEAREST);

      GLES30.glTexImage2D(GLES30.GL_TEXTURE_2D, 0, GLES30.GL_DEPTH_COMPONENT, mSizeX, mSizeY, 0, GLES30.GL_DEPTH_COMPONENT, GLES30.GL_UNSIGNED_SHORT, null);

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

      GLES30.glFramebufferTexture2D(GLES30.GL_FRAMEBUFFER, GLES30.GL_DEPTH_ATTACHMENT, GLES30.GL_TEXTURE_2D, mDepthH[0], 0);

      checkStatus("depth");

      }

    if( !mDepthEnabled && mDepthH[0]!=NOT_CREATED_YET ) // we need to detach and destroy the DEPTH attachment.

      {

      GLES30.glDeleteTextures(1, mDepthH, 0);

      mDepthH[0]=NOT_CREATED_YET;

      }

    }

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

  private boolean checkStatus(String message)

    {

    int status = GLES30.glCheckFramebufferStatus(GLES30.GL_FRAMEBUFFER);

    if(status != GLES30.GL_FRAMEBUFFER_COMPLETE)

      {

      android.util.Log.e("DistortedFramebuffer", "FRAMEBUFFER INCOMPLETE, "+message+" error="+status);

      GLES30.glDeleteTextures(1, mColorH, 0);

      GLES30.glDeleteTextures(1, mDepthH, 0);

      GLES30.glDeleteFramebuffers(1, mFBOH, 0);

      mFBOH[0]   = 0;

      mColorH[0] = FAILED_TO_CREATE;

      mDepthH[0] = FAILED_TO_CREATE;

      return false;

      }

    return true;

    }

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

// Must be called from a thread holding OpenGL Context

  private void delete()

    {

    if( mColorH[0]>=0 )

      {

      if( mDepthH[0]>=0 )

        {

        GLES30.glDeleteTextures(1, mDepthH, 0);

        mDepthH[0]=NOT_CREATED_YET;

        }

      GLES30.glDeleteTextures(1, mColorH, 0);

      mColorH[0] = NOT_CREATED_YET;

      GLES30.glDeleteFramebuffers(1, mFBOH, 0);

      mFBOH[0] = 0;

      }

    mMarked = false;

    }

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

  void setAsOutput()

    {

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

    if( mDepthH[0]!=NOT_CREATED_YET )

      {

      GLES30.glEnable(GLES30.GL_DEPTH_TEST);

      GLES30.glDepthMask(true);

      }

    else

      {

      GLES30.glDisable(GLES30.GL_DEPTH_TEST);

      GLES30.glDepthMask(false);

      }

    }

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

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

        }

      }

    }

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

  static synchronized void onDestroy()

    {

    for( DistortedFramebuffer fbo : mList)

      {

      if( fbo.mColorH[0]!=DONT_CREATE ) fbo.mColorH[0] = NOT_CREATED_YET;

      if( fbo.mDepthEnabled           ) fbo.mDepthH[0] = NOT_CREATED_YET;

      }

    }

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

// must be called form a thread holding OpenGL Context

  private static synchronized void deleteAllMarked()

    {

    if( mListMarked )

      {

      DistortedFramebuffer tmp;

      Iterator<DistortedFramebuffer> iterator = mList.iterator();

      while(iterator.hasNext())

        {

        tmp = iterator.next();

        if( tmp.mMarked )

          {

          tmp.delete();

          iterator.remove();

          }

        }

      mListMarked = false;

      }

    }

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

// if new size fits into the size of the underlying Texture, just change the projection without

// reallocating the Texture. Otherwise, we need to reallocate.

//

// Must be called form a thread holding the OpenGL context.

  void resizeFast(int width, int height)

    {

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

      {

      mWidth = width;

      mHeight= height;

      createProjection();

      if( mWidth> mSizeX || mHeight> mSizeY)

        {

        mSizeX = mWidth;

        mSizeY = mHeight;

        delete();

        }

      }

    create();

    }

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

// PUBLIC API

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

/**

 * Create a new offscreen Framebuffer.

 *

 * @param width Width of the COLOR attachment.

 * @param height Height of the COLOR attachment.

 * @param depthEnabled Add DEPTH attachment?

 */

  @SuppressWarnings("unused")

  public DistortedFramebuffer(int width, int height, boolean depthEnabled)

    {

    mProjectionMatrix = new float[16];

    mHeight      = height;

    mWidth       = width;

    mSizeY       = height;

    mSizeX       = width;

    mFOV         = 60.0f;

    mX           = 0.0f;

    mY           = 0.0f;

    mMarked      = false;

    mDepthEnabled= depthEnabled;

    mFBOH[0]  =-1;

    mColorH[0]= NOT_CREATED_YET;

    mDepthH[0]= NOT_CREATED_YET;

    createProjection();

    mList.add(this);

    }

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

/**

 * Create a new offscreen Framebuffer.

 *

 * @param width Width of the COLOR attachment.

 * @param height Height of the COLOR attachment.

 */

  @SuppressWarnings("unused")

  public DistortedFramebuffer(int width, int height)

    {

    mProjectionMatrix = new float[16];

    mHeight      = height;

    mWidth       = width;

    mSizeY       = height;

    mSizeX       = width;

    mFOV         = 60.0f;

    mX           = 0.0f;

    mY           = 0.0f;

    mMarked      = false;

    mDepthEnabled= false;

    mFBOH[0]  =-1;

    mColorH[0]= NOT_CREATED_YET;

    mDepthH[0]= NOT_CREATED_YET;

    createProjection();

    mList.add(this);

    }

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

/**

 * Create a new Framebuffer from an already created OpenGL Framebuffer.

 * <p>

 * Has to be followed by a 'resize()' to set the size.

 *

 * @param fbo the ID of a OpenGL Framebuffer object. Typically 0 (the screen)

 */

  public DistortedFramebuffer(int fbo)

    {

    mProjectionMatrix = new float[16];

    mFOV         = 60.0f;

    mX           = 0.0f;

    mY           = 0.0f;

    mMarked      = false;

    mDepthEnabled= true;

    mFBOH[0]  = fbo;

    mColorH[0]= DONT_CREATE;

    mDepthH[0]= DONT_CREATE;

    }

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

/**

 * Create a new DEPTH buffer and attach it or (param=false) detach an existing DEPTh attachment and destroy 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 enableDepthAttachment(boolean enable)

    {

    mDepthEnabled = enable;

    }

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

/**

 * Draw the (texture,mesh,effects) object to the Framebuffer.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param tex input Texture to use.

 * @param mesh Class descendant from MeshObject

 * @param effects The DistortedEffects to use when rendering

 * @param time Current time, in milliseconds.

 */

  public void renderTo(DistortedTexture tex, MeshObject mesh, DistortedEffects effects, long time)

    {

    tex.create();

    if( tex.setAsInput() )

      {

      DistortedFramebuffer.deleteAllMarked();

      DistortedTexture.deleteAllMarked();

      create();

      effects.drawPriv(tex.getWidth()/2.0f, tex.getHeight()/2.0f, mesh, this, time);

      }

    }

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

/**

 * Draw the (framebuffer,mesh,effects) object to the Framebuffer.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param fbo The Framebuffer (previously created with the first constructor, drawing FROM the screen

 *            is unsupported!) whose COLOR attachment 0 will be used as input texture.

 *            Please note that rendering from an FBO to itself is unsupported by OpenGL!

 * @param mesh Class descendant from MeshObject

 * @param effects The DistortedEffects to use when rendering

 * @param time Current time, in milliseconds.

 */

  public void renderTo(DistortedFramebuffer fbo, MeshObject mesh, DistortedEffects effects, long time)

    {

    fbo.create();

    if( fbo.setAsInput() )

      {

      DistortedFramebuffer.deleteAllMarked();

      DistortedTexture.deleteAllMarked();

      create();

      effects.drawPriv(fbo.getWidth()/2.0f, fbo.getHeight()/2.0f, mesh, this, time);

      }

    }

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

/**

 * Draws the Tree, and all its children, to the Framebuffer.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param dt DistortedTree to render.

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

 */

  public void renderTo(DistortedTree dt, long time)

    {

    DistortedFramebuffer.deleteAllMarked();

    DistortedTexture.deleteAllMarked();

    create();

    dt.drawRecursive(time,this);

    }

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

/**

 * Mark the underlying OpenGL object for deletion. Actual deletion will take place on the next render.

 */

  public void markForDeletion()

    {

    //android.util.Log.e("FBO", "marking for deletion ("+mWidth+","+mHeight+") "+mFBOH[0]);

    mListMarked = true;

    mMarked     = true;

    }

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

/**

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

 *

 * As the Framebuffer is not created until the first render, typical usage of this API is actually

 * to set the size of an not-yet-created Framebuffer of an object that has been created with the

 * second constructor.

 * <p>

 * Fully creating an object, rendering to it, then resizing mid-render is also possible. Actual

 * resize takes place on the next render.

 *

 * @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( mColorH[0]>0 ) markForDeletion();

      }

    }

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

/**

 * Return the ID of the Texture (COLOR attachment 0) that's backing this FBO.

 * <p>

 * Catch: this will only work if the library has had time to actually create the texture. Remember

 * that the texture gets created only on first render, thus creating a Texture object and immediately

 * calling this method will return an invalid (negative) result.

 *

 * @return If there was not a single render between creation of the Object and calling this method on

 *         it, return a negative value. Otherwise, return ID of COLOR attachment 0.

 */

  public int getTextureID()

    {

    return mColorH[0];

    }

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

/**

 * Return true if the FBO contains a DEPTH attachment.

 *

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

 */

  public boolean hasDepth()

    {

    return mDepthEnabled;

    }

  }