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

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

import android.graphics.Bitmap;

import android.opengl.GLUtils;

import org.distorted.library.type.Data4D;

 * General idea is as follows:

 * <ul>

 * <li> Create an instance of (some class descended from) DistortedObject

 * <li> Paint something onto the Bitmap that's backing it up

 * <li> Apply some effects

 * <li> Draw it!

 * </ul>

 * <p>

 * The effects we can apply fall into three general categories:

 * <ul>

 * <li> Matrix Effects, i.e. ones that change the Bitmap's ModelView Matrix (moves, scales, rotations)

 * <li> Vertex Effects, i.e. effects that are implemented in the Vertex Shader. Those typically change

 *      the shape of (some sub-Region of) the Bitmap in some way (deforms, distortions, sinks)

 * <li> Fragment Effects, i.e. effects that change (some of) the pixels of the Bitmap (transparency, macroblock)

 * </ul>

 * <p>

 * DistortedObjects currently created by the application so that we can implement the 'mark for

 * deletion now - actually delete on next render' thing.

 * We need to be able to quickly retrieve an Object by its ID, thus a HashMap.

  private static HashMap<Long,DistortedObject> mObjects = new HashMap<>();

  private EffectQueueFragment  mF;

  private EffectQueueVertex    mV;

  private boolean matrixCloned, vertexCloned, fragmentCloned;

  private long mID;

  private int mSizeX, mSizeY, mSizeZ; // in screen space

  int[] mTextureDataH;         // have to be shared among all the cloned Objects

  boolean[] mBitmapSet;        //

// We have to flip vertically every single Bitmap that we get fed with.

//

// Reason: textures read from files are the only objects in OpenGL which have their origins at the

// upper-left corner. Everywhere else the origin is in the lower-left corner. Thus we have to flip.

// The alternative solution, namely inverting the y-coordinate of the TexCoord does not really work-

// i.e. it works only in case of rendering directly to the screen, but if we render to an FBO and

// then take the FBO and render to screen, (DistortedNode does so!) things get inverted as textures

// created from FBO have their origins in the lower-left... Mindfuck!

  private static Bitmap flipBitmap(Bitmap src)

    {

    Matrix matrix = new Matrix();

    matrix.preScale(1.0f,-1.0f);

    return Bitmap.createBitmap(src,0,0,src.getWidth(),src.getHeight(), matrix,true);

    }

    mSizeY= y;

    mSizeZ= z;

    mObjects.put(mID,this);

    mTextureDataH[0]= 0;

    mBmp            = new Bitmap[1];

    mBmp[0]         = null;

    mBitmapSet      = new boolean[1];

    mBitmapSet[0]   = false;

    }

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

      matrixCloned = true;

      }

    else

      {

      mM = new EffectQueueMatrix(d);

      matrixCloned = false;

      }

      {

      mV = d.mV;

      vertexCloned = true;

      }

    else

      {

      mV = new EffectQueueVertex(d);

      vertexCloned = false;

      }

      {

      mF = d.mF;

      fragmentCloned = true;

      {

      mF = new EffectQueueFragment(d);

      fragmentCloned = false;

      }

    }

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

// this will be called on startup and every time OpenGL context has been lost

// also call this from the constructor if the OpenGL context has been created already.

    if( mTextureDataH!=null )

      GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR );

      GLES20.glTexParameteri ( 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_CLAMP_TO_EDGE );

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

        {

      }

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

    mV.send();

    mF.send();

    }

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

    mM.sendZero(df);

    mF.sendZero();

    mGrid.draw();

    }

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

    if( !vertexCloned  ) mV.abortAll(false);

    if( !fragmentCloned) mF.abortAll(false);

    mBmp          = null;

    mGrid         = null;

    mM            = null;

    mV            = null;

    mF            = null;

    mTextureDataH = null;

    }

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

    return mBmp==null ? 0 : mBmp.hashCode();

    }

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

  static synchronized void reset()

    {

    for(long id: mObjects.keySet())

      }

    }

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

  static synchronized void release()

    {

    for(long id: mObjects.keySet())

      {

      mObjects.get(id).releasePriv();

    mNextID = 0;

    }

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

// PUBLIC API

 * Default empty constructor so that derived classes can call it

 */

  public DistortedObject()

    {

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

 * Copy constructor used to create a DistortedObject based on various parts of another object.

 * <p>

 * Whatever we do not clone gets created just like in the default constructor.

 * We only call this from the descendant's classes' constructors where we have to pay attention

 * to give it the appropriate type of a DistortedObject!

 *

 * @param dc    Source object to create our object from

 * @param flags A bitmask of values specifying what to copy.

 *              For example, CLONE_BITMAP | CLONE_MATRIX.

 */

  public DistortedObject(DistortedObject dc, int flags)

    {

    initializeEffectLists(dc,flags);

    mObjects.put(mID,this);

    mSizeY = dc.mSizeY;

    mSizeZ = dc.mSizeZ;

    mGrid  = dc.mGrid;

      {

      mTextureDataH = dc.mTextureDataH;

      mBmp          = dc.mBmp;

      mBitmapSet    = dc.mBitmapSet;

      {

      mTextureDataH   = new int[1];

      mTextureDataH[0]= 0;

      mBitmapSet      = new boolean[1];

      mBitmapSet[0]   = false;

      mBmp            = new Bitmap[1];

      mBmp[0]         = null;

      if( Distorted.isInitialized() ) resetTexture();

      }

    }

/**

 * Draw the DistortedObject to the location specified by current Matrix effects.    

 *     

 */

    {

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

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

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

/**

 * Draw the DistortedObject to the Framebuffer passed.

 *

 * @param currTime Current time, in milliseconds.

 * @param df       Framebuffer to render this to.

 */

  public void draw(long currTime, DistortedFramebuffer df)

    {

    df.setAsOutput();

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

    drawPriv(currTime,df);

    }

/**

 * Releases all resources.

 */

    releasePriv();

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

/**

 * Sets the underlying android.graphics.Bitmap object and uploads it to the GPU. 

 * <p>

 * You can only recycle() the passed Bitmap once the OpenGL context gets created (i.e. after call 

 * to onSurfaceCreated) because only after this point can the Library upload it to the GPU!

 * 

 * @param bmp The android.graphics.Bitmap object to apply effects to and display.

 */

    {

    mBitmapSet[0] = true;

      {

      GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

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

    else

      {

      mBmp[0] = bmp;

      }

    }

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

/**

 * Adds the calling class to the list of Listeners that get notified each time some event happens 

 * @param el A class implementing the EffectListener interface that wants to get notifications.

 */

    {

    mV.addListener(el);

    mF.addListener(el);

    mM.addListener(el);

    }

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

/**

 * Removes the calling class from the list of Listeners.

 * 

 * @param el A class implementing the EffectListener interface that no longer wants to get notifications.

 */

    {

    mV.removeListener(el);

    mF.removeListener(el);

    mM.removeListener(el);

    }

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

/**

 * Returns the height of the DistortedObject.

 *    

 * @return height of the object, in pixels.

 */

     return mSizeX;   

     }

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

/**

 * Returns the width of the DistortedObject.

 * 

 * @return width of the Object, in pixels.

 */

      return mSizeY;  

      }

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

/**

 * Returns the depth of the DistortedObject.

 * 

 * @return depth of the Object, in pixels.

 */

      return mSizeZ;  

      }

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

/**

 * Returns unique ID of this instance.

 * 

 * @return ID of the object.

 */

      return mID;  

      }

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

/**

 * @return Number of effects aborted.

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

/**

 * @return Number of effects aborted.

    {

    switch(type)

      case VERTEX  : return mV.abortAll(true);

      case FRAGMENT: return mF.abortAll(true);

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

/**

 * Aborts a single Effect.

 * 

 * @param id ID of the Effect we want to abort.

    {

    int type = (int)(id&EffectTypes.MASK);

    if( type==EffectTypes.VERTEX.type   ) return mV.removeByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type ) return mF.removeByID(id>>EffectTypes.LENGTH);

    }

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

/**

    {

    switch(name.getType())

      case VERTEX  : return mV.removeByType(name);

      case FRAGMENT: return mF.removeByType(name);

      default      : return 0;

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

/**

 * Print some info about a given Effect to Android's standard out. Used for debugging only.

 * 

 * @param id Effect ID we want to print info about

 * @return <code>true</code> if a single Effect of type effectType has been found.

 */

    {

    int type = (int)(id&EffectTypes.MASK);

    if( type==EffectTypes.VERTEX.type   )  return mV.printByID(id>>EffectTypes.LENGTH);

    if( type==EffectTypes.FRAGMENT.type )  return mF.printByID(id>>EffectTypes.LENGTH);

    }

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

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

// Individual effect functions.

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

// Matrix-based effects

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

/**

 * @return       ID of the effect added, or -1 if we failed to add one.

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

/**

 * @return      ID of the effect added, or -1 if we failed to add one.

/**

 * @param scale The factor to scale all 3 dimensions with.

 * @return      ID of the effect added, or -1 if we failed to add one.

 */

    {

    return mM.add(EffectNames.SCALE, new Static3D(scale,scale,scale));

    }

/**

 * Static axis of rotation is given by the last parameter.

 *

 */

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

/**

 * @param angleaxis Combined 4-tuple representing the (angle,axisX,axisY,axisZ).

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

/**

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

/**

 *                of shearing in the X-axis, second - Y-axis and the third -

 *                Z-axis. Each is the tangens of the shear angle, i.e 0 -

 *                no shear, 1 - shear by 45 degrees (tan(45deg)=1) etc.

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

// Fragment-based effects  

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

/**

 *               Valid range: <0,1>

 * @param smooth If true, the level of 'blend' will smoothly fade out towards the edges of the region.

 * @return       ID of the effect added, or -1 if we failed to add one.

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

/**

 *

 * @param blend  1-dimensional Data that returns the level of blend a given pixel will be

 *               Valid range: <0,1>

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

/**

 *               Valid range: <0,1>

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

/**

 *

 * @param alpha  1-dimensional Data that returns the level of transparency we want to have at any

 *               Valid range: <0,1>

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

/**

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

/**

 *

 * @param brightness 1-dimensional Data that returns the level of brightness we want to have

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

/**

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

/**

 *

 * @param contrast 1-dimensional Data that returns the level of contrast we want to have

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

/**