Distorted Android

  private void displayBoundingRect(float halfX, float halfY, float halfZ, DistortedOutputSurface surface, float[] mvp, float[] vertices)

    DistortedProjection projection = surface.getProjection();

      wx = (int)(projection.mWidth *(ndcX+1)/2);

      wy = (int)(projection.mHeight*(ndcY+1)/2);

    surface.setAsOutput();

    Matrix.translateM  ( mTmpMatrix, 0, minx-projection.mWidth/2, maxy-projection.mHeight/2, -projection.mDistance);

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

  void drawPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedOutputSurface surface, long currTime)

    DistortedProjection projection = surface.getProjection();

    GLES30.glViewport(0, 0, projection.mWidth, projection.mHeight);

      surface.setAsOutput();

      mM.send(projection,halfInputW,halfInputH,halfZ);

        mM.constructMatrices(projection,halfInputW,halfInputH);

        mP.render(2*halfInputW, 2*halfInputH, mM.getMVP(), surface);

        mBufferFBO.resizeFast(projection.mWidth, projection.mHeight);

        mM.send(mBufferFBO.getProjection(),halfInputW,halfInputH,halfZ);

        Matrix.translateM(mTmpMatrix, 0, 0, 0, -projection.mDistance);

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

        mP.render(projection.mWidth, projection.mHeight, mMVPMatrix, surface);

  static void drawNoEffectsPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedProjection projection)

    GLES30.glViewport(0, 0, projection.mWidth, projection.mHeight);

    Matrix.translateM(mTmpMatrix, 0, 0, 0, -projection.mDistance);

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

    EffectQueueMatrix.sendZero(projection,halfInputW,halfInputH,halfInputW*mesh.zFactor);

 * User is able to create offscreen FBOs and both a) render to them b) use their COLOR0 attachment as

 * an input texture.

public class DistortedFramebuffer extends DistortedRenderable implements DistortedInputSurface, DistortedOutputSurface

  private DistortedProjection mProjection;

  public void create()

    if( mProjection.resize(width,height) )

      if( width> mSizeX || height> mSizeY)

        mSizeX = width;

        mSizeY = height;

    mProjection  = new DistortedProjection(width,height);

    mProjection  = new DistortedProjection(width,height);

 * Bind the underlying rectangle of pixels as a OpenGL Texture.

  public boolean setAsInput()

    if( mColorH[0]>0 )

      {

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

      return true;

      }

    return false;

    }

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

/**

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

 */

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

      }

 * @param surface InputSurface to skin our Mesh with.

  public void renderTo(DistortedInputSurface surface, MeshObject mesh, DistortedEffects effects, long time)

    surface.create();  // Watch out  - this needs to be before

    create();          // the 'setAsInput' because this has side-effects!

    if( surface.setAsInput() )

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

    mProjection.set(fov,x,y);

    mProjection.createProjection();

    if( mProjection.resize(width,height) )

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

/**

 * Return Projection stored in this Framebuffer.

 *

 * @return DistortedProjection object.

 */

  public DistortedProjection getProjection()

    {

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

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

/**

 * A Surface that we can set as Input, i.e. take its rectangle of pixels and skin our Mesh with it.

 */

public interface DistortedInputSurface extends DistortedSurface

{

/**

 * Take the underlying rectangle of pixels and bind this texture to OpenGL.

 */

  boolean setAsInput();

}

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

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

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

/**

 * A Surface that we can set as Output, i.e. render to it.

 */

public interface DistortedOutputSurface extends DistortedSurface

{

/**

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

 */

 void setAsOutput();

/**

 * Return the Projection.

 */

 DistortedProjection getProjection();

}

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

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

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

class DistortedProjection

{

  private float mX, mY, mFOV;

  int mWidth,mHeight,mDepth;

  float mDistance;

  float[] mProjectionMatrix;

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

  DistortedProjection()

    {

    mProjectionMatrix = new float[16];

    mWidth = 0;

    mHeight= 0;

    mFOV = 60.0f;

    mX   =  0.0f;

    mY   =  0.0f;

    }

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

  DistortedProjection(int width, int height)

    {

    mProjectionMatrix = new float[16];

    mWidth = width;

    mHeight= height;

    mFOV = 60.0f;

    mX   =  0.0f;

    mY   =  0.0f;

    createProjection();

    }

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

  boolean resize(int width, int height)

    {

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

      {

      mWidth = width;

      mHeight= height;

      createProjection();

      return true;

      }

    return false;

    }

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

  void set(float fov, float x, float y)

    {

    mFOV = fov;

    mX = x;

    mY = y;

    }

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

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

        }

      }

    }

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

}

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

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

*/

abstract class DistortedRenderable implements DistortedSurface

  public abstract void create();

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

/**

 * Return unique ID of the Renderable.

 */

  public long getID()

    {

    return mColorH[0];

    }

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

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

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

/**

 * Class which represents the Screen.

 * <p>

 * User is able to render to it just like to a DistortedFramebuffer.

 */

public class DistortedScreen extends DistortedRenderable implements DistortedOutputSurface

  {

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

  private DistortedProjection mProjection;

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

  public void create() {}

  void delete() {}

  void destroy() {}

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

// PUBLIC API

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

/**

 * Create a new Screen.

 * <p>

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

 */

  public DistortedScreen()

    {

    super(0,0,DONT_CREATE);

    mProjection  = new DistortedProjection();

    mFBOH[0]     = 0;

    }

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

/**

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

 */

  public void setAsOutput()

    {

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

    GLES30.glEnable(GLES30.GL_DEPTH_TEST);

    GLES30.glDepthMask(true);

    }

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

/**

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

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param surface InputSurface to skin our Mesh with.

 * @param mesh Class descendant from MeshObject

 * @param effects The DistortedEffects to use when rendering

 * @param time Current time, in milliseconds.

 */

  public void renderTo(DistortedInputSurface surface, MeshObject mesh, DistortedEffects effects, long time)

    {

    surface.create();  // Watch out  - this needs to be before

    create();          // the 'setAsInput' because this has side-effects!

    if( surface.setAsInput() )

      {

      DistortedRenderable.deleteAllMarked();

      effects.drawPriv(surface.getWidth()/2.0f, surface.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)

    {

    DistortedRenderable.deleteAllMarked();

    create();

    dt.drawRecursive(time,this);

    }

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

/**

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

    {

    mProjection.set(fov,x,y);

    mProjection.createProjection();

    }

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

/**

 * Resize the underlying Projection.

 *

 * @param width The new width.

 * @param height The new height.

 */

  public void resize(int width, int height)

    {

    if( mProjection.resize(width,height) )

      {

      mSizeX = width;

      mSizeY = height;

      }

    }

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

/**

 * Return Projection stored in this Framebuffer.

 *

 * @return DistortedProjection object.

 */

  public DistortedProjection getProjection()

    {

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

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

/**

 * Abstract Surface.

 */

interface DistortedSurface

{

/**

 * Create the underlying OpenGL part of the Surface.

 */

  void create();

/**

 * Return a unique ID of this Surface.

 */

  long getID();

/**

 * Return the width of this Surface.

 */

  int getWidth();

/**

 * Return the height of this Surface.

 */

  int getHeight();

}

public class DistortedTexture extends DistortedRenderable implements DistortedInputSurface

  public void create()

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

/**

 * Bind the underlying rectangle of pixels as a OpenGL Texture.

 */

  public boolean setAsInput()

    {

    if( mColorH[0]>0 )

      {

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

      return true;

      }

    return false;

    }

  private DistortedInputSurface mSurface;

    ret.add( mSurface.getID() );

          mData.mFBO = new DistortedFramebuffer(mSurface.getWidth(), mSurface.getHeight());

  void drawRecursive(long currTime, DistortedOutputSurface surface)

    mSurface.create();

    float halfX = mSurface.getWidth()/2.0f;

    float halfY = mSurface.getHeight()/2.0f;

      mSurface.setAsInput();

        if( mSurface.setAsInput() )

          DistortedEffects.drawNoEffectsPriv(halfX, halfY, mMesh, mData.mFBO.getProjection() );

    mEffects.drawPriv(halfX, halfY, mMesh, surface, currTime);

 * @param surface InputSurface to put into the new Node.

  public DistortedTree(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    mSurface       = surface;

    list.add(mSurface.getID());

      mSurface = node.mSurface;

      int w = node.mSurface.getWidth();

      int h = node.mSurface.getHeight();

      if( node.mSurface instanceof DistortedTexture )

        mSurface = new DistortedTexture(w,h);

      else if( node.mSurface instanceof DistortedFramebuffer )

        boolean hasDepth = ((DistortedFramebuffer) node.mSurface).hasDepth();

        mSurface = new DistortedFramebuffer(w,h,hasDepth);

 * @param surface InputSurface to initialize our child Node with.

  public synchronized DistortedTree attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    DistortedTree node = new DistortedTree(surface,effects,mesh);

 * Returns the DistortedInputSurface object that's in the Node.

 * @return The DistortedInputSurface contained in the Node.

  public DistortedInputSurface getSurface()

    return mSurface;

  void constructMatrices(DistortedProjection projection, float halfX, float halfY)

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

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

  synchronized void send(DistortedProjection projection, float halfX, float halfY, float halfZ)

    constructMatrices(projection,halfX,halfY);

    GLES30.glUniform1f( mDepthH, projection.mDepth);

  synchronized static void sendZero(DistortedProjection projection, float halfX, float halfY, float halfZ)

    Matrix.translateM(mTmpMatrix, 0, halfX-projection.mWidth/2, projection.mHeight/2-halfY, -projection.mDistance);

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

    GLES30.glUniform1f( mDepthH, projection.mDepth);

  synchronized void render(float w, float h, float[] mvp, DistortedOutputSurface surface)

    DistortedProjection inputP  = mBufferFBO.getProjection();

    DistortedProjection outputP = surface.getProjection();

    Matrix.translateM(mTmpMatrix, 0, 0, 0, -inputP.mDistance);

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

    surface.setAsOutput();

    GLES30.glViewport(0, 0, outputP.mWidth, outputP.mHeight);