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

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 WRITE-only Framebuffers from objects already constructed outside

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

 * FBOs (used by the DistortedNode, but also can be used by external users of the library)

 * <p>

 * Also, 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 place and actual deletion takes place

 * on the next render).

 */

public class DistortedFramebuffer

  {

  private static final int TEXTURE_FAILED_TO_CREATE = -1;

  private static final int TEXTURE_NOT_CREATED_YET  = -2;

  private static final int TEXTURE_DONT_CREATE      = -3;

  private static boolean mListMarked = false;

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

  private float mX, mY;

  private float mFOV;

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

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

  private boolean mMarked;

  int mWidth,mHeight,mDepth,mDistance;

  float[] mProjectionMatrix;

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

  private void createProjection()

    {

    if( mFOV>0.0f )  // perspective projection

      {

      float ratio  = (float) mWidth / mHeight;

      float left   =-ratio;

      float right  = ratio;

      float bottom = -1.0f;

      float top    =  1.0f;

      float near= (float)(top / Math.tan(mFOV*Math.PI/360));

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

      float far = 2*mDistance-near;

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

      if( far<=0 )

        {

        android.util.Log.e("FBO", "error: far<=0. width="+mWidth+" height="+mHeight+

                           " mFOV="+mFOV+" mDistance="+mDistance+" far="+far+" near="+near);

        }

      else

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

      }

    else             // parallel projection

      {

      float left   =-mWidth/2;

      float right  = mWidth/2;

      float bottom =-mHeight/2;

      float top    = mHeight/2;

      float near= (float)(top / Math.tan(Math.PI/360));

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

      float far = 2*mDistance-near;

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

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

      }

    }

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

// must be called form a thread holding OpenGL Context

  private boolean createFBO()

    {

    GLES20.glGenTextures(1, texIds, 0);

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texIds[0]);

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

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

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

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

    GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, mWidth, mHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);

    GLES20.glGenFramebuffers(1, fboIds, 0);

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboIds[0]);

    GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, texIds[0], 0);

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

    if(status != GLES20.GL_FRAMEBUFFER_COMPLETE)

      {

      android.util.Log.e("DistortedFramebuffer", "failed to create framebuffer, error="+status);

      GLES20.glDeleteTextures(1, texIds, 0);

      GLES20.glDeleteFramebuffers(1, fboIds, 0);

      fboIds[0] = 0;

      texIds[0] = TEXTURE_FAILED_TO_CREATE;

      return false;

      }

    mList.add(this);

    android.util.Log.e("FBO", "created ("+mWidth+","+mHeight+") "+fboIds[0]);

    return true;

    }

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

// must be called form a thread holding OpenGL Context

  private void deleteFBO()

    {

    android.util.Log.e("FBO", "deleting ("+mWidth+","+mHeight+") "+fboIds[0]);

    GLES20.glDeleteTextures(1, texIds, 0);

    GLES20.glDeleteFramebuffers(1, fboIds, 0);

    fboIds[0] = 0;

    texIds[0] = TEXTURE_NOT_CREATED_YET;

    }

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

// must be called from a thread holding OpenGL Context

  private void delete()

    {

    if( texIds[0]>=0 ) deleteFBO();

    mProjectionMatrix = null;

    mMarked = false;

    }

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

  void reset()

    {

    texIds[0] = TEXTURE_NOT_CREATED_YET;

    }

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

  static synchronized void release()

    {

    mListMarked = false;

    mList.clear();

    }

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

// must be called form a thread holding OpenGL Context

  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;

      }

    }

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

// PUBLIC API

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

/**

 * Create a new offscreen FBO.

 *

 * @param width Width of the COLOR attachment.

 * @param height Height of the COLOR attachment.

 */

  public DistortedFramebuffer(int width, int height)

    {

    mProjectionMatrix = new float[16];

    mHeight        = height;

    mWidth         = width;

    fboIds[0]      = -1;

    texIds[0]      = TEXTURE_NOT_CREATED_YET;

    mFOV           = 60.0f;

    mX             = 0.0f;

    mY             = 0.0f;

    mMarked = false;

    createProjection();

    }

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

/**

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

 *

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

 */

  public DistortedFramebuffer(int fbo)

    {

    mProjectionMatrix = new float[16];

    fboIds[0]      = fbo;

    texIds[0]      = TEXTURE_DONT_CREATE;

    mFOV           = 60.0f;

    mX             = 0.0f;

    mY             = 0.0f;

    mMarked = false;

    }

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

/**

 * 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+") "+fboIds[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. -mWidth/2 < x < mWidth/2

 * @param y Y-coordinate of the point at which our camera looks at. -mHeight/2 < y < mHeight/2

 */

  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.

 *

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

      createProjection();

      if( texIds[0]>0 ) markForDeletion();

      }

    }

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

/**

 * Set this as the Framebuffer to write to.

 */

  public void setAsOutput()

    {

    if( texIds[0]==TEXTURE_NOT_CREATED_YET ) createFBO();

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboIds[0]);

    }

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

/**

 * Set this as the Framebuffer to read from.

 */

  public void setAsInput()

    {

    if( texIds[0]==TEXTURE_NOT_CREATED_YET ) createFBO();

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texIds[0]);

    }

  }