Distorted Android

  static DistortedProjection mProjection = new DistortedProjection();

  static float mFOV = 60.0f;

    mFOV = fov;

    if( mProjection.width>0 && mProjection.height>0 )

      mProjection.onSurfaceChanged( mProjection.width, mProjection.height);

    mProjection.onSurfaceChanged(surfaceWidth, surfaceHeight);

  private static final int TEXTURE_FAILED_TO_CREATE = -1;   

  private static final int TEXTURE_NOT_CREATED_YET  = -2;   

  private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();

  private static long mNextNodeID =0;

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

    long ID;  

    int mFramebufferID;

    int mTextureID;

    DistortedProjection mProjection;

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

   NodeData(long id)

     {

     ID = id;

     numPointingNodes= 1;

     mFramebufferID = 0;

     mTextureID = TEXTURE_NOT_CREATED_YET;

     mProjection = null;

     mRendered = false;

     }

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

    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, mProjection.width, mProjection.height, 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("Node", "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;

      }

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

    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;

   }

  private void drawRecursive(long currTime, DistortedProjection dp, int mFBO)

      if( mData.mProjection!=null )

        {

        mData.deleteFBO();

        mData.mProjection = null;

        }

        if( mData.mTextureID==TEXTURE_NOT_CREATED_YET ) mData.createFBO();

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mData.mFramebufferID);

          mObject.drawNoEffectsPriv(mData.mProjection);

            mChildren.get(i).drawRecursive(currTime, mData.mProjection, mData.mFramebufferID);

      GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFBO);

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mData.mTextureID);   // this is safe because we must have called createFBO() above before.     

    mObject.drawPriv(currTime, dp);

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

        {     

        mData.mProjection = new DistortedProjection();

        mData.mProjection.onSurfaceChanged(mObject.getWidth(), mObject.getHeight());

        mData.mFramebufferID = 0;

        mData.mTextureID = TEXTURE_NOT_CREATED_YET;

        }

      if( tmp.mProjection!=null )

    	  tmp.mTextureID = TEXTURE_NOT_CREATED_YET;

    drawRecursive(currTime,Distorted.mProjection,0);

  void drawPriv(long currTime, DistortedProjection dp)

    GLES20.glViewport(0, 0, dp.width, dp.height);

    mM.send(dp);

  void drawNoEffectsPriv(DistortedProjection dp)

    GLES20.glViewport(0, 0, dp.width, dp.height);

    mM.sendZero(dp);

    drawPriv(currTime, Distorted.mProjection);

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

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

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

/**

 * Only used within the Distorted Library itself.

 */

class DistortedProjection

  {

  int width,height,depth,distance;

  float[] projectionMatrix;

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

  DistortedProjection()

   {

   projectionMatrix = new float[16];   

   }

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

  void onSurfaceChanged(int surfaceWidth, int surfaceHeight)

    {

    width = surfaceWidth;

    height= surfaceHeight;  

    float ratio  = (float) surfaceWidth / surfaceHeight;

    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( Distorted.mFOV>0.0f )  // perspective projection

      {  

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

      distance = (int)(height*near/(top-bottom));

      far = 2*distance-near;

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

      }

    else                      // parallel projection

      {

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

      distance = (int)(height*near/(top-bottom));

      far = 2*distance-near;

      Matrix.orthoM(projectionMatrix, 0, -surfaceWidth/2, surfaceWidth/2,-surfaceHeight/2, surfaceHeight/2, near, far);

      }

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

    }

  }

    mFramebufferID = -1;

  public void release()

    if( mTextureID>=0 ) deleteFBO();

    mProjectionMatrix = null;

    mWidth = width;

    mHeight= height;

    createProjection();

    if( mTextureID>0 ) deleteFBO();

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

  public void use()

  synchronized void send(DistortedProjection dp)

    Matrix.translateM(mViewMatrix, 0, -dp.width/2, dp.height/2, -dp.distance);

    Matrix.multiplyMM(mMVPMatrix, 0, dp.projectionMatrix, 0, mViewMatrix, 0);

    GLES20.glUniform1f( mDepthH, dp.depth);   

  synchronized void sendZero(DistortedProjection dp)

    Matrix.translateM(mTmpMatrix, 0, mObjHalfX-dp.width/2, dp.height/2-mObjHalfY, -dp.distance);

    Matrix.multiplyMM(mMVPMatrix, 0, dp.projectionMatrix, 0, mTmpMatrix, 0);

    GLES20.glUniform1f( mDepthH, dp.depth);