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

import android.opengl.GLUtils;

import org.distorted.library.type.Data3D;

import org.distorted.library.type.Data4D;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.type.DynamicQuat;

    private static final Static3D mZero3D = new Static3D(0,0,0);

    private static float[] mViewMatrix   = new float[16];

    protected EffectQueueFragment  mF;

    protected EffectQueueVertex    mV;

    protected boolean matrixCloned, vertexCloned, fragmentCloned;

    protected int mSizeX, mSizeY, mSizeZ, mSize; // in screen space

    protected Bitmap[] mBmp= null; // 

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

    boolean[] mBitmapSet;          // 

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

    protected void initializeData(int size)

      {

      mID             = DistortedObjectList.add(this);

      mSize           = size;

      mTextureDataH   = new int[1];

      mTextureDataH[0]= 0;

      mBmp            = new Bitmap[1];

      mBmp[0]         = null;

      mBitmapSet      = new boolean[1];

      mBitmapSet[0]   = false;

      initializeEffectLists(this,0);

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

      }

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

    protected void initializeEffectLists(DistortedObject d, int flags)

      {

        mM = d.mM;

        matrixCloned = true;

        } 

      else

        {

        }

      if( (flags & Distorted.CLONE_VERTEX) != 0 )

        {

        mV = d.mV;

        vertexCloned = true;

        } 

      else

        {

        }

      if( (flags & Distorted.CLONE_FRAGMENT) != 0 )

        {

        mF = d.mF;

        fragmentCloned = true;

        } 

      else

        {

        }

      }

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

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

    void resetTexture()

      {

      if( mTextureDataH!=null ) 

        {

        if( mTextureDataH[0]==0 ) GLES20.glGenTextures(1, mTextureDataH, 0);

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

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

        if( mBmp!=null && mBmp[0]!=null)

          {

          GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, mBmp[0], 0);

          mBmp[0] = null;

          }

        }

      }

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

    void drawPriv(long currTime, DistortedProjection dp)

      {

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

      mM.compute(currTime);

      mM.send(mViewMatrix, dp);

      mV.compute(currTime);

      mV.postprocess();

      mV.send();

      mF.compute(currTime);

      mF.postprocess(mViewMatrix);

      mF.send();

      mGrid.draw();

      }

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

    void drawNoEffectsPriv(DistortedProjection dp)

      {

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

      mM.sendNoEffects(dp);

      mV.sendZero();

      mF.sendZero();

      mGrid.draw();

      }

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

    void releasePriv()

      {

      if( matrixCloned  ==false) mM.abortAll();

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

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

      mBmp          = null;

      mGrid         = null;

      mM            = null;

      mV            = null;

      mF            = null;

      mTextureDataH = null;

      }

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

    long getBitmapID()

      {

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

      }

  /**

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

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

    public DistortedObject(DistortedObject dc, int flags)

      {

      initializeEffectLists(dc,flags);

      mID = DistortedObjectList.add(this);

      mSizeX = dc.mSizeX;

      mSizeY = dc.mSizeY;

      mSizeZ = dc.mSizeZ;

      mSize  = dc.mSize;

      mGrid  = dc.mGrid;

      if( (flags & Distorted.CLONE_BITMAP) != 0 )

        {

        mTextureDataH = dc.mTextureDataH;

        mBmp          = dc.mBmp;

        mBitmapSet    = dc.mBitmapSet;

        }

      else

        {

        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.    

 *     

 * @param currTime current time, in milliseconds, as returned by System.currentTimeMillis().

 *        This gets passed on to Interpolators inside the Effects that are currently applied to the 

 *        Object.

 */

   public void draw(long currTime)

     {

     GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

     GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

     GLES20.glUniform1i(Distorted.mTextureUniformH, 0);  

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

     drawPriv(currTime, Distorted.mProjection);

     }

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

/**

 * Releases all resources.

 */

   public synchronized void release()

     {

     releasePriv();  

     DistortedObjectList.remove(this);

     }

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

/**

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

 */

   public void setBitmap(Bitmap bmp)

     {

     mBitmapSet[0] = true; 

     if( Distorted.isInitialized() )

       {

       GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

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

       GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bmp, 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.

 */

   public void addEventListener(EffectListener el)

     {

     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.

 */

   public void removeEventListener(EffectListener el)

     {

     mV.removeListener(el);

     mF.removeListener(el);

     mM.removeListener(el);

     }

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

/**

 * Returns the height of the DistortedObject.

 *    

 * @return height of the object, in pixels.

 */

   public int getWidth()

     {

     return mSizeX;   

     }

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

/**

 * Returns the width of the DistortedObject.

 * 

 * @return width of the Object, in pixels.

 */

    public int getHeight()

      {

      return mSizeY;  

      }

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

/**

 * Returns the depth of the DistortedObject.

 * 

 * @return depth of the Object, in pixels.

 */

    public int getDepth()

      {

      return mSizeZ;  

      }

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

/**

 * Returns unique ID of this instance.

 * 

 * @return ID of the object.

 */

    public long getID()

      {

      return mID;  

      }

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

/**

 * @return Number of effects aborted.

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

/**

 * @return Number of effects aborted.

        {

        case MATRIX  : return mM.abortAll();

        case VERTEX  : return mV.abortAll();

        case FRAGMENT: return mF.abortAll();

        default      : return 0;

        }

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

/**

 * Aborts a single Effect.

 * 

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

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

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

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

/**

 * Abort all Effects of a given type, for example all rotations.

 * 

        case VERTEX  : return mV.removeByType(name);

        case FRAGMENT: return mF.removeByType(name);

      }

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

/**

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

 */

    public boolean printEffect(long id)

      {

      if( type==EffectTypes.MATRIX.type   )  return mM.printByID(id>>EffectTypes.LENGTH);

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

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

      return false;

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

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

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

/**

 * Scales the Object by one uniform factor in all 3 dimensions. Convenience function.

 *

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

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

 */

public long scale(float scale)

  {

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

  }

/**

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

 *

 */

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

/**

 * @param center    Coordinates of the Point we are rotating around.

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

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

    {

    return mM.add(EffectNames.ROTATE, center, angleaxis);

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

/**

 * @param quaternion The quaternion describing the rotation.

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

    {

    return mM.add(EffectNames.QUATERNION,center,quaternion);

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

/**

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

// Fragment-based effects  

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

/**

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

/**

 * @param size   1-dimensional Data which, at any given time, returns the size of the macroblocks.

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

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

/**

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

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

/**

 *                    Level of blend a given pixel will be mixed with the next parameter 'color':

 *                    pixel = (1-t)*pixel + t*color

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

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

/**

 *

 * @param blendcolor  4-dimensional Data returning the 4-tuple (blend,R,G,B).

 *                    Level of blend a given pixel will be mixed with the next parameter 'color':

 *                    pixel = (1-t)*pixel + t*color

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

/**

 *               moment.

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

/**

 *

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

 *               given moment.

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

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

/**

 * @param region     Region this Effect is limited to.

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

/**

 *

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

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

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

/**

 * @param region   Region this Effect is limited to.

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

/**

 *

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

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

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

/**

 * @param region     Region this Effect is limited to.

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

/**

 *

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

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

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

// Vertex-based effects  

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

// DISTORT

/**