Distorted Android

apply plugin: 'com.android.library'

android {

    compileSdkVersion 22

    buildToolsVersion "23.0.3"

    defaultConfig {

        minSdkVersion 15

        targetSdkVersion 23

    }

    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'

        }

    }

}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="org.distorted.library"

    android:versionCode="1"

    android:versionName="1.0" >

    <uses-sdk

        android:minSdkVersion="10"

        android:targetSdkVersion="19" />

</manifest>

package org.distorted.library;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import android.opengl.GLSurfaceView;

import android.opengl.GLES20;

import android.os.Build;

import android.util.Log;

import org.distorted.library.R;

import org.distorted.library.exception.*;

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

/**

 * A singleton class used to control various global settings.

 */

public class Distorted 

{

  /**

   * When creating an instance of a DistortedBitmap from another instance, do not clone anything.

   * Used in the copy constructor.

   */

  public static final int CLONE_NOTHING = 0x0;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Bitmap that's

   * backing up our DistortedObject. 

   * <p>

   * This way we can have two DistortedObjects, both backed up by the same Bitmap, to which we can 

   * apply different effects. Used in the copy constructor.

   */

  public static final int CLONE_BITMAP  = 0x1;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Matrix Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always displayed in exactly the same place on the screen. Applying any matrix-based effect to 

   * one of them automatically applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_MATRIX  = 0x2;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Vertex Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always with the same Vertex effects. Applying any vertex-based effect to one of them automatically 

   * applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_VERTEX  = 0x4;

  /**

   * When creating an instance of a DistortedObject from another instance, clone the Fragment Effects.

   * <p>

   * This way we can have two different DistortedObjects with different Bitmaps behind them, both 

   * always with the same Fragment effects. Applying any fragment-based effect to one of them automatically 

   * applies the effect to the other. Used in the copy constructor.

   */

  public static final int CLONE_FRAGMENT= 0x8;

  /**

   * When creating an instance of a DistortedNode from another instance, clone the children Nodes.

   * <p>

   * This is mainly useful for creating many similar sub-trees of Bitmaps and rendering then at different places

   * on the screen, with (optionally) different effects of the top-level root Bitmap.   

   */

  public static final int CLONE_CHILDREN= 0x10;

  /**

  * Constant used to represent a Matrix-based effect.

  */

  public static final int TYPE_MATR = 0x1;

  /**

   * Constant used to represent a Vertex-based effect.

   */

  public static final int TYPE_VERT = 0x2;

  /**

   * Constant used to represent a Fragment-based effect.

   */

  public static final int TYPE_FRAG = 0x4;

  private static final String TAG = Distorted.class.getSimpleName();

  private static boolean mInitialized = false;

  static int mPositionH;      // pass in model position information

  static int mColorH;         // pass in model color information

  static int mTextureUniformH;// pass in the texture.

  static int mNormalH;        // pass in model normal information.

  static int mTextureCoordH;  // pass in model texture coordinate information.

  static int mProgramH;       // This is a handle to our shading program.  

  static DistortedProjection mProjection = new DistortedProjection(false);

  static float mFOV = 60.0f;

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

  private Distorted()

    {

    }

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

  private static void sanitizeMaxValues() throws VertexUniformsException,FragmentUniformsException

    {

    int maxV,maxF;  

    int[] param = new int[1];

    GLES20.glGetIntegerv(GLES20.GL_MAX_VERTEX_UNIFORM_VECTORS, param, 0);

    maxV = param[0];

    GLES20.glGetIntegerv(GLES20.GL_MAX_FRAGMENT_UNIFORM_VECTORS, param, 0);

    maxF = param[0];

    Log.d(TAG, "Max vectors in vertex shader: "+maxV);

    Log.d(TAG, "Max vectors in fragment shader: "+maxF);

    if( Build.FINGERPRINT.startsWith("generic") == false )

      {

      int realMaxV = (maxV-11)/4;   // adjust this in case of changes to the shaders...

      int realMaxF = (maxF- 2)/4;   //

      if( EffectListVertex.getMax() > realMaxV )

        {

        throw new VertexUniformsException("Too many effects in the vertex shader, max is "+realMaxV, realMaxV);

        }

      if( EffectListFragment.getMax() > realMaxF )

        {

        throw new FragmentUniformsException("Too many effects in the fragment shader, max is "+realMaxF, realMaxF);

        }

      }

    }

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

  private static int compileShader(final int shaderType, final String shaderSource) throws FragmentCompilationException,VertexCompilationException

    {

    int shaderHandle = GLES20.glCreateShader(shaderType);

    if (shaderHandle != 0) 

      {

      GLES20.glShaderSource(shaderHandle, "#version 100 \n"+ generateShaderHeader(shaderType) + shaderSource);

      GLES20.glCompileShader(shaderHandle);

      final int[] compileStatus = new int[1];

      GLES20.glGetShaderiv(shaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);

      if (compileStatus[0] != GLES20.GL_TRUE ) 

        {

        GLES20.glDeleteShader(shaderHandle);

        shaderHandle = 0;

        }

      }

    if (shaderHandle == 0)

      {     

      String error = GLES20.glGetShaderInfoLog(shaderHandle);

      switch(shaderType)

        {

        case GLES20.GL_VERTEX_SHADER  : throw new VertexCompilationException(error); 

        case GLES20.GL_FRAGMENT_SHADER: throw new FragmentCompilationException(error);

        default                       : throw new RuntimeException(error);

        }

      }

    return shaderHandle;

    }

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

  private static int createAndLinkProgram(final int vertexShaderHandle, final int fragmentShaderHandle, final String[] attributes) throws LinkingException

    {

    int programHandle = GLES20.glCreateProgram();

    if (programHandle != 0) 

      {

      GLES20.glAttachShader(programHandle, vertexShaderHandle);         

      GLES20.glAttachShader(programHandle, fragmentShaderHandle);

      if (attributes != null)

        {

        final int size = attributes.length;

        for (int i = 0; i < size; i++)

          {

          GLES20.glBindAttribLocation(programHandle, i, attributes[i]);

          }                

        }

      GLES20.glLinkProgram(programHandle);

      final int[] linkStatus = new int[1];

      GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);

      if (linkStatus[0] != GLES20.GL_TRUE ) 

        {         

        String error = GLES20.glGetProgramInfoLog(programHandle);

        GLES20.glDeleteProgram(programHandle);

        throw new LinkingException(error);

        }

      final int[] numberOfUniforms = new int[1];

      GLES20.glGetProgramiv(programHandle, GLES20.GL_ACTIVE_UNIFORMS, numberOfUniforms, 0);

      android.util.Log.d(TAG, "number of active uniforms="+numberOfUniforms[0]);

      }

    return programHandle;

    }

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

  private static String generateShaderHeader(final int type)

    {

    String header="";

    switch(type)

      {

      case GLES20.GL_VERTEX_SHADER  : header += ("#define NUM_VERTEX "  +EffectListVertex.getMax()+"\n");

                                      for(EffectNames name: EffectNames.values() )

                                        {

                                        if( name.getType()==TYPE_VERT )  

                                        header += ("#define "+name.name()+" "+name.ordinal()+"\n");  

                                        }

                                      break;

      case GLES20.GL_FRAGMENT_SHADER: header += ("#define NUM_FRAGMENT "+EffectListFragment.getMax()+"\n");

                                      for(EffectNames name: EffectNames.values() )

                                        {

                                        if( name.getType()==TYPE_FRAG )  

                                        header += ("#define "+name.name()+" "+name.ordinal()+"\n");  

                                        }

                                      break;

     }

    //Log.d(TAG,""+header);

    return header;

    }

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

  private static String readTextFileFromRawResource(final GLSurfaceView v, final int resourceId)

    {

    final InputStream inputStream = v.getContext().getResources().openRawResource(resourceId);

    final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);

    final BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    String nextLine;

    final StringBuilder body = new StringBuilder();

    try

      {

      while ((nextLine = bufferedReader.readLine()) != null)

        {

        body.append(nextLine);

        body.append('\n');

        }

      }

    catch (IOException e)

      {

      return null;

      }

    return body.toString();

    }

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

  private static String getVertexShader(final GLSurfaceView v)

    {

    return readTextFileFromRawResource( v, R.raw.main_vertex_shader);

    }

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

  private static String getFragmentShader(final GLSurfaceView v)

    {

    return readTextFileFromRawResource( v, R.raw.main_fragment_shader);

    }

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

// Public API

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

/**

 * Sets Vertical Field of View angle. This changes the Projection Matrix.  

 *   

 * @param fov Vertical Field Of View angle, in degrees. If T is the middle of the top edge of the 

 *            screen, E is the eye point, and B is the middle of the bottom edge of the screen, then 

 *            fov = angle(TEB)

 */

  public static void setFov(float fov)

    {

    mFOV = fov;

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

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

    }

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

/**

 * When OpenGL context gets created, you need to call this method so that the library can initialise its internal data structures.

 * I.e. best called from GLSurfaceView.onSurfaceCreated().

 * <p>

 * Compiles the vertex and fragment shaders, establishes the addresses of all uniforms, and initialises all Bitmaps that have already

 * been created.

 *   

 * @param v The Surface that just got created.

 * @throws FragmentCompilationException

 * @throws VertexCompilationException

 * @throws VertexUniformsException

 * @throws FragmentUniformsException

 * @throws LinkingException

 */

  public static void onSurfaceCreated(GLSurfaceView v) throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException

    { 

    mInitialized = true;  

// String ver;  

    final String vertexShader   = Distorted.getVertexShader(v);         

    final String fragmentShader = Distorted.getFragmentShader(v);       

/*

    ver = GLES20.glGetString(GLES20.GL_SHADING_LANGUAGE_VERSION);    

    Log.d(TAG, "GLSL version: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_VERSION);   

    Log.d(TAG, "GL version: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_VENDOR);    

    Log.d(TAG, "GL vendor: "+(ver==null ? "null" : ver) );

    ver = GLES20.glGetString(GLES20.GL_RENDERER);  

    Log.d(TAG, "GL renderer: "+(ver==null ? "null" : ver) );

*/

    //ver = GLES20.glGetString(GLES20.GL_EXTENSIONS);    

    //Log.d(TAG, "GL extensions: "+(ver==null ? "null" : ver) );

    sanitizeMaxValues();

    final int vertexShaderHandle   = compileShader(GLES20.GL_VERTEX_SHADER  , vertexShader  );     

    final int fragmentShaderHandle = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader);     

    mProgramH = createAndLinkProgram(vertexShaderHandle, fragmentShaderHandle, new String[] {"a_Position",  "a_Color", "a_Normal", "a_TexCoordinate"});                                                            

    GLES20.glUseProgram(mProgramH);

    GLES20.glEnable (GLES20.GL_DEPTH_TEST);

    GLES20.glDepthFunc(GLES20.GL_LEQUAL);

    GLES20.glEnable(GLES20.GL_BLEND);

    GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);

    mTextureUniformH = GLES20.glGetUniformLocation(mProgramH, "u_Texture");

    mPositionH       = GLES20.glGetAttribLocation( mProgramH, "a_Position");

    mColorH          = GLES20.glGetAttribLocation( mProgramH, "a_Color");

    mNormalH         = GLES20.glGetAttribLocation( mProgramH, "a_Normal"); 

    mTextureCoordH   = GLES20.glGetAttribLocation( mProgramH, "a_TexCoordinate");

    EffectListFragment.getUniforms(mProgramH);

    EffectListVertex.getUniforms(mProgramH);

    EffectListMatrix.getUniforms(mProgramH);

    GLES20.glEnableVertexAttribArray(mPositionH);        

    GLES20.glEnableVertexAttribArray(mColorH);

    GLES20.glEnableVertexAttribArray(mNormalH);

    GLES20.glEnableVertexAttribArray(mTextureCoordH);

    DistortedObjectList.reset();

    DistortedNode.reset();

    EffectMessageSender.startSending();

    }

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

/**

 * Call this when the physical size of the surface we are rendering to changes.

 * I.e. must be called from GLSurfaceView.onSurfaceChanged()  

 *   

 * @param surfaceWidth  new width of the surface.

 * @param surfaceHeight new height of the surface.

 */

  public static void onSurfaceChanged(int surfaceWidth, int surfaceHeight)

    {

    mProjection.onSurfaceChanged(surfaceWidth, surfaceHeight);

    }

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

/**

 * Call this so that the Library can release its internal data structures.

 * Must be called from Activity.onDestroy(). 

 */

  public static void onDestroy()

    {

    DistortedObjectList.release();

    EffectListVertex.reset();

    EffectListFragment.reset();

    EffectListMatrix.reset();

    EffectMessageSender.stopSending();

    mInitialized = false;

    }

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

/**

 * Returns the true if onSurfaceCreated has been called already, and thus if the Library's is ready

 * to accept effect requests.

 * 

 * @return <code>true</code> if the Library is ready for action, <code>false</code> otherwise.

 */

  public static boolean isInitialized()

    {

    return mInitialized;  

    }

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

/**

 * Returns the maximum number of Matrix effects.

 *    

 * @return The maximum number of Matrix effects

 */

  public static int getMaxMatrix()

    {

    return EffectListMatrix.getMax();  

    }

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

/**

 * Returns the maximum number of Vertex effects.

 *    

 * @return The maximum number of Vertex effects

 */  

  public static int getMaxVertex()

    {

    return EffectListVertex.getMax();  

    }

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

/**

 * Returns the maximum number of Fragment effects.

 *    

 * @return The maximum number of Fragment effects

 */  

  public static int getMaxFragment()

    {

    return EffectListFragment.getMax();  

    }

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

/**

 * Sets the maximum number of Matrix effects that can be applied to a single DistortedBitmap at one time.

 * This can fail if the value of 'max' is outside permitted range. 

 * 

 * @param max new maximum number of simultaneous Matrix Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxMatrix(int max)

    {

    return EffectListMatrix.setMax(max);  

    }

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

/**

 * Sets the maximum number of Vertex effects that can be applied to a single DistortedBitmap at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called 

 *     before the Vertex Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this

 *     time only decreasing the value of 'max' is permitted.  

 * </ul>

 * 

 * @param max new maximum number of simultaneous Vertex Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxVertex(int max)

    {

    return EffectListVertex.setMax(max);  

    }

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

/**

 * Sets the maximum number of Fragment effects that can be applied to a single DistortedBitmap at one time.

 * This can fail if:

 * <ul>

 * <li>the value of 'max' is outside permitted range

 * <li>We try to increase the value of 'max' when it is too late to do so already. It needs to be called 

 *     before the Fragment Shader gets compiled, i.e. before the call to {@link #onSurfaceCreated}. After this

 *     time only decreasing the value of 'max' is permitted.  

 * </ul>

 * 

 * @param max new maximum number of simultaneous Fragment Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE 

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxFragment(int max)

    {

    return EffectListFragment.setMax(max);  

    }

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

//end of file  

}

package org.distorted.library;

import android.graphics.Bitmap;

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

/**

 * Wrapper around the standard Android Bitmap class to which one can apply graphical effects.

 * <p>

 * General idea is as follows:

 * <ul>

 * <li> Create an instance of DistortedBitmap

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

 * 

 */

public class DistortedBitmap extends DistortedObject

   {

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

// PUBLIC API

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

/**

 * Default constructor: creates a DistortedBitmap (width,height) pixels in size, with the distortion

 * grid of size 'size' and does not fill it up with any Bitmap data just yet.

 * <p>

 * Distortion grid is a grid of rectangles the Bitmap is split to. The vertices of this grid are then 

 * moved around by the Vertex Shader to create various Vertex Effects.

 * <p>

 * Size parameter describes the horizontal size, i.e. the number of rectangles the top (or bottom) edge

 * is split to. So when size=1, the whole Bitmap is just one giant rectangle. When size=10, the Bitmap

 * is split into a grid of 10x10 rectangles.

 * <p>

 * The higher the size, the better Vertex Effects look; on the other hand too high size will slow things 

 * down.  

 *       

 * @param width  width of the DistortedBitmap, in pixels.

 * @param height height of the DistortedBitmap, in pixels.

 * @param size Horizontal size of the distortion grid. 2<=size&lt;256.

 */

   public DistortedBitmap(int width, int height, int gridSize)

     {     

     int xsize = gridSize;

     int ysize = xsize*height/width;

     if( xsize<2   ) xsize=  2;

     if( xsize>256 ) xsize=256;

     if( ysize<2   ) ysize=  2;

     if( ysize>256 ) ysize=256;

     mSizeX= width;

     mSizeY= height;

     mSizeZ= 1;     

     mGrid = new GridBitmap(xsize,ysize);

     initializeData(gridSize);

     }

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

/**

 * Creates a DistortedBitmap and immediately fills it up with Bitmap data.

 * The dimensions of the created DistortedBitmap object are the same like that of the passed Bitmap.

 *       

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

 * @param size Horizontal size of the distortion grid. 1<=size&lt;256.

 */

   public DistortedBitmap(Bitmap bmp, int gridSize)

     {

     this(bmp.getWidth(), bmp.getHeight(), gridSize); 

     setBitmap(bmp);

     }

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

/**

 * Copy constructor used to create a DistortedBitmap based on various parts of another Bitmap.

 * <p>

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

 *    

 * @param db    Source DistortedBitmap to create our object from

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

 *              For example, CLONE_BITMAP | CLONE_MATRIX.

 */

   public DistortedBitmap(DistortedBitmap db, int flags)

     {

     initializeEffectLists(db,flags);  

     mID = DistortedObjectList.add(this);

     mSizeX = db.mSizeX;

     mSizeY = db.mSizeY;

     mSizeZ = db.mSizeZ;

     mSize  = db.mSize;

     mGrid  = db.mGrid;

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

       {

       mTextureDataH = db.mTextureDataH;

 	    mBmp          = db.mBmp;

 	    mBitmapSet    = db.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();

       }

     }

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

}

package org.distorted.library;

import android.graphics.Bitmap;

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

/**

 * Instance of this class represents a connected, flat set of cubes optionally textured as a whole.

 * (a subset of a NxMx1 cuboid build with 1x1x1 cubes, i.e. the MxNx1 cuboid with arbitrary cubes missing)

 * <p>

 * General idea is as follows:

 * <ul>

 * <li> Create an instance of this class

 * <li> Optionally texture it

 * <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 Cuboid'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 Cuboid in some way (deforms, distortions, sinks)

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

 * </ul>

 * <p>

 * 

 */

public class DistortedCubes extends DistortedObject

   {

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

// PUBLIC API

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

/**

 * Creates internal memory representation of a cuboid subset.

 * 

 * @param cols Integer helping to parse the next parameter.

 * @param desc String describing the subset of a MxNx1 cuboid that we want to create.

 *             Its MxN characters - all 0 or 1 - decide of appropriate field is taken or not.

 *             

 *             For example, (cols=2, desc="111010") describes the following shape:

 *             

 *             XX

 *             X

 *             X

 *             

 *             whereas (cols=2,desc="110001") describes

 *             

 *             XX

 *              

 *              X

 *              

 * @param gridSize size, in pixels, of the single 1x1x1 cube our cuboid is built from

 *  

 */   

   public DistortedCubes(int cols, String desc, int gridSize) 

     {

     this(cols,desc,gridSize,false);

     }

/**

 * @param frontOnly Only create the front wall or side and back as well?

 */

   public DistortedCubes(int cols, String desc, int gridSize, boolean frontOnly) 

     {

     int Rs = 0;

     int Cs = 0;

     if( cols>0 )

       {

       int reallen = desc.length();

       int len = reallen;

       if( (reallen/cols)*cols != reallen )

         {

         len = ((reallen/cols)+1)*cols; 

         for(int i=reallen; i<len; i++) desc += "0";

         }

       if( desc.indexOf("1")>=0 )

         {

         Cs = cols;

         Rs = len/cols;

         }

       }

     mSizeX= gridSize*Cs;

     mSizeY= gridSize*Rs;

     mSizeZ= frontOnly ? 0 : gridSize;

     mGrid = new GridCubes(cols,desc, frontOnly);

     initializeData(gridSize);

     }

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

/**

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

 * <p>

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

 *    

 * @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 DistortedCubes(DistortedCubes 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(); 

       }

     }

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

   }

package org.distorted.library;

import java.util.ArrayList;

import java.util.HashMap;

import android.opengl.GLES20;

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

/**

 * Class which represents a Node in a Tree of DistortedBitmaps.

 *  

 * Having organized a set of DistortedBitmaps into a Tree, we can then render any Node to any Framebuffer.

 * That recursively renders the Bitmap held in the Node and all its children, along with whatever effects

 * each one of them has. 

 */

public class DistortedNode 

  {

  private static final int TEXTURE_FAILED_TO_CREATE = -1;   

  private static final int TEXTURE_NOT_CREATED_YET  = -2;   

  private DistortedBitmap mBitmap;

  private NodeData mData;

  private DistortedNode mParent;

  private ArrayList<DistortedNode> mChildren;

  private int[] mNumChildren;  // ==mChildren.length(), but we only create mChildren if the first one gets added

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

  private static long mNextNodeID =0;

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

  private class NodeData

    {

    long ID;  

    int numPointingNodes;

    int mFramebufferID;

    int mTextureID;

    DistortedProjection mProjection;

    boolean mRendered;

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

   public 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 markRecursive()

    {

    mData.mRendered = false;

    synchronized(this)

      {

      for(int i=0; i<mNumChildren[0]; i++) mChildren.get(i).markRecursive();

      }

    }

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

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

    {

    if( mNumChildren[0]<=0 )

      {

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

      if( mData.mProjection!=null )

        {

        mData.deleteFBO();

        mData.mProjection = null;

        }

      }

    else

      {

      if( mData.mRendered==false )

        {

        mData.mRendered = true;

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

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

        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        if( mBitmap.mBitmapSet[0] )

          {

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

          mBitmap.drawNoEffectsPriv(mData.mProjection);

          }

        synchronized(this)

          {

          for(int i=0; i<mNumChildren[0]; i++)

            {

            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.     

      }

    mBitmap.drawPriv(currTime, dp);

    }

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

// tree isomorphism

  private void RecomputeNodeID(ArrayList<Long> prev)

    {

    ArrayList<Long> curr = generateIDList();

    if( mParent==null )

      {

      adjustNodeData(prev,curr);

      }

    else

      {

      ArrayList<Long> parentPrev = mParent.generateIDList();

      adjustNodeData(prev,curr);

      mParent.RecomputeNodeID(parentPrev);

      }

    }

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

  private ArrayList<Long> generateIDList()

    {

    ArrayList<Long> ret = new ArrayList<Long>();

    ret.add( mNumChildren[0]>0 ? mBitmap.getBitmapID() : mBitmap.getID() );

    DistortedNode node;

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      ret.add(node.mData.ID);

      }

    return ret;

    }

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

  private void adjustNodeData(ArrayList<Long> oldList, ArrayList<Long> newList)

    {

    if( mData.numPointingNodes>1 ) mData.numPointingNodes--;

    else                           mMapNodeID.remove(oldList);  

    NodeData newData = mMapNodeID.get(newList);

    if( newData==null )

      {

      mData.ID = ++mNextNodeID;  

      mData.numPointingNodes = 1;

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

        {     

        mData.mProjection = new DistortedProjection(true);

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

        mData.mFramebufferID = 0;

        mData.mTextureID = TEXTURE_NOT_CREATED_YET;

        }

      mMapNodeID.put(newList, mData);

      }

    else

      {  

      newData.numPointingNodes++;

      mData = newData;

      }

    }

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

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

  static void reset()

    {

    NodeData tmp;   

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      if( tmp.mProjection!=null )

        {

    	  tmp.mTextureID = TEXTURE_NOT_CREATED_YET;

        tmp.mRendered  = false;

        }

      }

    }

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

// PUBLIC API

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

/**

 * Constructs new Node of the Tree.

 *     

 * @param bmp DistortedBitmap to put into the new Node.

 */

  public DistortedNode(DistortedBitmap bmp)

    {

    mBitmap = bmp;

    mParent = null;

    mChildren = null;

    mNumChildren = new int[1];

    mNumChildren[0] = 0;

    ArrayList<Long> list = new ArrayList<Long>();

    list.add(bmp.getID());

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);  

      }

    }

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

/**

 * Copy-constructs new Node of the Tree from another Node.

 *     

 * @param node The DistortedNode to copy data from.

 * @param flags bit field composed of a subset of the following:

 *        {@link Distorted#CLONE_BITMAP},  {@link Distorted#CLONE_MATRIX}, {@link Distorted#CLONE_VERTEX},

 *        {@link Distorted#CLONE_FRAGMENT} and {@link Distorted#CLONE_CHILDREN}.

 *        For example flags = CLONE_BITMAP | CLONE_CHILDREN.

 */

  public DistortedNode(DistortedNode node, int flags)

    {

    mParent = null;  

    mBitmap = new DistortedBitmap(node.mBitmap, flags);  

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

      {

      mChildren = node.mChildren;

      mNumChildren = node.mNumChildren;

      }

    else

      {

      mChildren = null;

      mNumChildren = new int[1];

      mNumChildren[0] = 0;

      }

    ArrayList<Long> list = generateIDList();

    mData = mMapNodeID.get(list);

    if( mData!=null )

      {

      mData.numPointingNodes++;

      }

    else

      {

      mData = new NodeData(++mNextNodeID);   

      mMapNodeID.put(list, mData);

      }

    }

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

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 * @param node The new Node to add.

 * @return <code>true</code> if we successfully added the new child.

 */

  public synchronized void attach(DistortedNode node)

    {

    ArrayList<Long> prev = generateIDList(); 

    if( mChildren==null ) mChildren = new ArrayList<DistortedNode>(2);

    node.mParent = this;

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    }

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

/**

 * Adds a new child to the last position in the list of our Node's children.

 * 

 * @param bmp DistortedBitmap to initialize our child Node with.

 * @return the newly constructed child Node, or null if we couldn't allocate resources.

 */

  public synchronized DistortedNode attach(DistortedBitmap bmp)

    {

    ArrayList<Long> prev = generateIDList(); 

    if( mChildren==null ) mChildren = new ArrayList<DistortedNode>(2);  

    DistortedNode node = new DistortedNode(bmp);

    node.mParent = this;

    mChildren.add(node);

    mNumChildren[0]++;

    RecomputeNodeID(prev);

    return node;

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 * @param node The Node to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

  public synchronized boolean detach(DistortedNode node)

    {

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      if( mChildren.remove(node) )

        {

        node.mParent = null;  

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

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

/**

 * Removes the first occurrence of a specified child from the list of children of our Node.

 * 

 * @param bmp The DistortedBitmap to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

  public synchronized boolean detach(DistortedBitmap bmp)

    {

    long id = bmp.getID();

    DistortedNode node;

    for(int i=0; i<mNumChildren[0]; i++)

      {

      node = mChildren.get(i);

      if( node.mBitmap.getID()==id )

        {

        ArrayList<Long> prev = generateIDList();   

        node.mParent = null;  

        mChildren.remove(i);

        mNumChildren[0]--;

        RecomputeNodeID(prev);

        return true;

        }

      }

    return false;

    }

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

/**

 * Removes all children Nodes.

 */

  public synchronized void detachAll()

    {

    for(int i=0; i<mNumChildren[0]; i++)

      {

      mChildren.get(i).mParent = null;

      }

    if( mNumChildren[0]>0 )

      {

      ArrayList<Long> prev = generateIDList();  

      mNumChildren[0] = 0;

      mChildren.clear();

      RecomputeNodeID(prev);

      }

    }

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

/**

 * Draws the Node, and all its children, to the default framebuffer 0 (i.e. the screen).

 *   

 * @param currTime Current time, in milliseconds.

 */

  public void draw(long currTime)

    {  

    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

    GLES20.glUniform1i(Distorted.mTextureUniformH, 0);  

    markRecursive();

    drawRecursive(currTime,Distorted.mProjection,0);

    }

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

/**

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

 * 

 * @return The DistortedBitmap contained in the Node.

 */

  public DistortedBitmap getBitmap()

    {

    return mBitmap;  

    }

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

// Debug - print all the Node IDs

  public void debug(int depth)

    {

    String tmp="";  

    int i;

    for(i=0; i<depth; i++) tmp +="   ";

    tmp += (""+mData.ID);

    android.util.Log.e("node", tmp);

    for(i=0; i<mNumChildren[0]; i++)

      mChildren.get(i).debug(depth+1);

    }

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

  }

package org.distorted.library;

import android.graphics.Bitmap;

import android.opengl.GLES20;

import android.opengl.GLUtils;

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

public abstract class DistortedObject 

{ 

    static final int TYPE_NUM = 3;

    private static final int TYPE_MASK= (1<<TYPE_NUM)-1;

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

    protected EffectListMatrix   mM;

    protected EffectListFragment mF;

    protected EffectListVertex   mV;

    protected boolean matrixCloned, vertexCloned, fragmentCloned;

    protected GridObject mGrid = null;

    protected long mID;

    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)

      {

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

        {

        mM = d.mM;

        matrixCloned = true;

        } 

      else

        {

        mM = new EffectListMatrix(d);

        matrixCloned = false;  

        }

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

        {

        mV = d.mV;

        vertexCloned = true;

        } 

      else

        {

        mV = new EffectListVertex(d);

        vertexCloned = false;  

        }

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

        {

        mF = d.mF;

        fragmentCloned = true;

        } 

      else

        {

        mF = new EffectListFragment(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.

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

      }

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

/**