Distorted Android

  static DistortedRenderTarget mRenderTarget = new DistortedRenderTarget(0);

    mRenderTarget.setProjection(fov,0.0f,0.0f);

    mRenderTarget.resize(surfaceWidth,surfaceHeight);

    DistortedRenderTarget mDRT;

      mDRT            = null;

  private void drawRecursive(long currTime, DistortedRenderTarget drt)

        mData.mDRT.setOutput();

          mObject.drawNoEffectsPriv(mData.mDRT);

            mChildren.get(i).drawRecursive(currTime, mData.mDRT);

      drt.setOutput();

      mData.mDRT.setInput();   // this is safe because we must have called createFBO() above before.

    mObject.drawPriv(currTime, drt);

      if( newList.size()>1 && mData.mDRT==null )

        mData.mDRT = new DistortedRenderTarget(mObject.getWidth(), mObject.getHeight());

      if( tmp.mDRT != null )

    	  tmp.mDRT.reset();

    DistortedRenderTargetList.deleteAllMarked();

    drawRecursive(currTime,Distorted.mRenderTarget);

  void drawPriv(long currTime, DistortedRenderTarget drt)

    GLES20.glViewport(0, 0, drt.mWidth, drt.mHeight);

    mM.send(drt);

  void drawNoEffectsPriv(DistortedRenderTarget drt)

    GLES20.glViewport(0, 0, drt.mWidth, drt.mHeight);

    mM.sendZero(drt);

    drawPriv(currTime, Distorted.mRenderTarget);

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

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

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

public class DistortedRenderTarget

  {

  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 int mFramebufferID, mTextureID;

  private float mX, mY;

  private float mFOV;

  int mWidth,mHeight,mDepth,mDistance;

  float[] mProjectionMatrix;

  boolean mMarked;

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

  private void createProjection()

    {

    float ratio  = (float) mWidth / mHeight;

    float left   =-ratio;          //

    float right  = ratio;          // Create a new perspective projection matrix.

    float bottom = -1.0f;          //

    float top    =  1.0f;          // any change to those values will have serious consequences!

    float near, far;

    if( mFOV>0.0f )  // perspective projection

      {

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

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

      far = 2*mDistance-near;

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

      }

    else                      // parallel projection

      {

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

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

      far = 2*mDistance-near;

      Matrix.orthoM(mProjectionMatrix, 0, -mWidth/2, mWidth/2,-mHeight/2, mHeight/2, near, far);

      }

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

    }

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

// must be called form a thread holding OpenGL Context

  private boolean createFBO()

    {

    int[] textureIds = new int[1];

    GLES20.glGenTextures(1, textureIds, 0);

    mTextureID = textureIds[0];

    int[] mFBORenderToTexture = new int[1];

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureID);

    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, mFBORenderToTexture, 0);

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

    GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTextureID, 0);

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

    if(status != GLES20.GL_FRAMEBUFFER_COMPLETE)

      {

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

      GLES20.glDeleteTextures(1, textureIds, 0);

      GLES20.glDeleteFramebuffers(1, mFBORenderToTexture, 0);

      mFramebufferID = 0;

      mTextureID = TEXTURE_FAILED_TO_CREATE;

      return false;

      }

    mFramebufferID = mFBORenderToTexture[0];

    return true;

    }

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

// must be called form a thread holding OpenGL Context

  private void deleteFBO()

    {

    int[] textureIds = new int[1];

    int[] mFBORenderToTexture = new int[1];

    textureIds[0] = mTextureID;

    mFBORenderToTexture[0] = mFramebufferID;

    GLES20.glDeleteTextures(1, textureIds, 0);

    GLES20.glDeleteFramebuffers(1, mFBORenderToTexture, 0);

    mFramebufferID = 0;

    mTextureID = TEXTURE_NOT_CREATED_YET;

    }

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

// must be called form a thread holding OpenGL Context

  void release()

    {

    if( mTextureID>=0 ) deleteFBO();

    mProjectionMatrix = null;

    mMarked = false;

    }

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

  void reset()

    {

    mTextureID = TEXTURE_NOT_CREATED_YET;

    }

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

// PUBLIC API

  public DistortedRenderTarget(int width, int height)

    {

    mProjectionMatrix = new float[16];

    mHeight        = height;

    mWidth         = width;

    mFramebufferID = 0;

    mTextureID     = TEXTURE_NOT_CREATED_YET;

    mFOV           = 60.0f;

    mX             = 0.0f;

    mY             = 0.0f;

    mMarked = false;

    createProjection();

    }

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

  public DistortedRenderTarget(int fbo)

    {

    mProjectionMatrix = new float[16];

    mFramebufferID = fbo;

    mTextureID     = TEXTURE_DONT_CREATE;

    mFOV           = 60.0f;

    mX             = 0.0f;

    mY             = 0.0f;

    mMarked = false;

    }

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

  public void markForDeletion()

    {

    DistortedRenderTargetList.markForDeletion();

    mMarked = true;

    }

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

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

    {

    mFOV = FOV;

    mX   = x;

    mY   = y;

    createProjection();

    }

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

  public void resize(int width, int height)

    {

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

      {

      mWidth = width;

      mHeight= height;

      createProjection();

      if( mTextureID>0 ) markForDeletion();

      }

    }

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

  public int getFBO()

    {

    return mFramebufferID;

    }

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

// set this as Render Target to draw to. Must be called from a thread holding OpenGL context.

  public void setOutput()

    {

    if( mTextureID==TEXTURE_NOT_CREATED_YET ) createFBO();

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFramebufferID);

    }

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

// set this as Render Target to draw from. Must be called from a thread holding OpenGL context.

  public void setInput()

    {

    if( mTextureID==TEXTURE_NOT_CREATED_YET ) createFBO();

    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureID);

    }

  }

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

// 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 java.util.LinkedList;

import java.util.Iterator;

/**

 * List of all DistortedRenderTarget objects currently created by the application.

 *

 * The point: we need to be able ot mark RenderTargets for deletion, and delete all marked

 * objects later at a convenient time. Thus we keep all of them in a LinkedList here.

 */

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

final class DistortedRenderTargetList

  {

  private static boolean mMarked = false;

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

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

  static synchronized void add(DistortedRenderTarget drt)

    {

    mList.add(drt);

    }

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

  static synchronized void markForDeletion()

    {

    mMarked = true;

    }

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

// must be called form a thread holding OpenGL Context

  static synchronized void deleteAllMarked()

    {

    if( mMarked )

      {

      DistortedRenderTarget tmp;

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

      while(iterator.hasNext())

        {

        tmp = iterator.next();

        if( tmp.mMarked )

          {

          tmp.release();

          iterator.remove();

          }

        }

      mMarked = false;

      }

    }

  }

  synchronized void send(DistortedRenderTarget drt)

    Matrix.translateM(mViewMatrix, 0, -drt.mWidth/2, drt.mHeight/2, -drt.mDistance);

    Matrix.multiplyMM(mMVPMatrix, 0, drt.mProjectionMatrix, 0, mViewMatrix, 0);

    GLES20.glUniform1f( mDepthH, drt.mDepth);

  synchronized void sendZero(DistortedRenderTarget drt)

    Matrix.translateM(mTmpMatrix, 0, mObjHalfX-drt.mWidth/2, drt.mHeight/2-mObjHalfY, -drt.mDistance);

    Matrix.multiplyMM(mMVPMatrix, 0, drt.mProjectionMatrix, 0, mTmpMatrix, 0);

    GLES20.glUniform1f( mDepthH, drt.mDepth);