Distorted Android

        applicationId "org.distorted.examples"

    package="org.distorted.examples"

package org.distorted.examples;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import android.app.Activity;

import android.app.ListActivity;

import android.content.Intent;

import android.os.Bundle;

import android.util.SparseArray;

import android.view.View;

import android.widget.AdapterView;

import android.widget.AdapterView.OnItemClickListener;

import android.widget.SimpleAdapter;

import org.distorted.examples.R;

import org.distorted.examples.monalisa.MonaLisaActivity;

import org.distorted.examples.sink.SinkActivity;

import org.distorted.examples.fov.FOVActivity;

import org.distorted.examples.deform.DeformActivity;

import org.distorted.examples.listener.ListenerActivity;

import org.distorted.examples.interpolator.InterpolatorActivity;

import org.distorted.examples.girl.GirlActivity;

import org.distorted.examples.macroblock.MacroblockActivity;

import org.distorted.examples.movingeffects.MovingEffectsActivity;

import org.distorted.examples.olimpic.OlimpicActivity;

import org.distorted.examples.differenteffects.DifferentEffectsActivity;

import org.distorted.examples.differentbitmaps.DifferentBitmapsActivity;

import org.distorted.examples.scratchpad.ScratchpadActivity;

import org.distorted.examples.check.CheckActivity;

import org.distorted.examples.bean.BeanActivity;

import org.distorted.examples.fbo.FBOActivity;

import org.distorted.examples.starwars.StarWarsActivity;

import org.distorted.examples.cubes.CubesActivity;

import org.distorted.examples.quaternion.QuaternionActivity;

import org.distorted.examples.effects3d.Effects3DActivity;

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

public class TableOfContents extends ListActivity 

  {

  private static final String ITEM_IMAGE = "item_image";

  private static final String ITEM_TITLE = "item_title";

  private static final String ITEM_SUBTITLE = "item_subtitle"; 

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

  @Override

  public void onCreate(Bundle savedInstanceState) 

   {

   super.onCreate(savedInstanceState);

   setTitle(R.string.toc);

   setContentView(R.layout.table_of_contents);

   final List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();

   final SparseArray<Class<? extends Activity>> activityMapping = new SparseArray<Class<? extends Activity>>();

   int i = 0;

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_monalisa);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_monalisa));

      item.put(ITEM_SUBTITLE, getText(R.string.example_monalisa_subtitle));

      data.add(item);

      activityMapping.put(i++, MonaLisaActivity.class);        

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_sink);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_sink));

      item.put(ITEM_SUBTITLE, getText(R.string.example_sink_subtitle));

      data.add(item);

      activityMapping.put(i++, SinkActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_bean);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_bean));

      item.put(ITEM_SUBTITLE, getText(R.string.example_bean_subtitle));

      data.add(item);

      activityMapping.put(i++, BeanActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_fov);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_fov));

      item.put(ITEM_SUBTITLE, getText(R.string.example_fov_subtitle));

      data.add(item);

      activityMapping.put(i++, FOVActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_deform);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_deform));

      item.put(ITEM_SUBTITLE, getText(R.string.example_deform_subtitle));

      data.add(item);

      activityMapping.put(i++, DeformActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_listener);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_listener));

      item.put(ITEM_SUBTITLE, getText(R.string.example_listener_subtitle));

      data.add(item);

      activityMapping.put(i++, ListenerActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_interpolator);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_interpolator));

      item.put(ITEM_SUBTITLE, getText(R.string.example_interpolator_subtitle));

      data.add(item);

      activityMapping.put(i++, InterpolatorActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_girl);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_girl));

      item.put(ITEM_SUBTITLE, getText(R.string.example_girl_subtitle));

      data.add(item);

      activityMapping.put(i++, GirlActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_macroblock);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_macroblock));

      item.put(ITEM_SUBTITLE, getText(R.string.example_macroblock_subtitle));

      data.add(item);

      activityMapping.put(i++, MacroblockActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_movingeffects);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_movingeffects));

      item.put(ITEM_SUBTITLE, getText(R.string.example_movingeffects_subtitle));

      data.add(item);

      activityMapping.put(i++, MovingEffectsActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_differenteffects);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_differenteffects));

      item.put(ITEM_SUBTITLE, getText(R.string.example_differenteffects_subtitle));

      data.add(item);

      activityMapping.put(i++, DifferentEffectsActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_differentbitmaps);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_differentbitmaps));

      item.put(ITEM_SUBTITLE, getText(R.string.example_differentbitmaps_subtitle));

      data.add(item);

      activityMapping.put(i++, DifferentBitmapsActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_scratchpad);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_scratchpad));

      item.put(ITEM_SUBTITLE, getText(R.string.example_scratchpad_subtitle));

      data.add(item);

      activityMapping.put(i++, ScratchpadActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_check);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_check));

      item.put(ITEM_SUBTITLE, getText(R.string.example_check_subtitle));

      data.add(item);

      activityMapping.put(i++, CheckActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_fbo);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_fbo));

      item.put(ITEM_SUBTITLE, getText(R.string.example_fbo_subtitle));

      data.add(item);

      activityMapping.put(i++, FBOActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_starwars);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_starwars));

      item.put(ITEM_SUBTITLE, getText(R.string.example_starwars_subtitle));

      data.add(item);

      activityMapping.put(i++, StarWarsActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_olimpic);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_olimpic));

      item.put(ITEM_SUBTITLE, getText(R.string.example_olimpic_subtitle));

      data.add(item);

      activityMapping.put(i++, OlimpicActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_quaternion);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_quaternion));

      item.put(ITEM_SUBTITLE, getText(R.string.example_quaternion_subtitle));

      data.add(item);

      activityMapping.put(i++, QuaternionActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_cubes);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_cubes));

      item.put(ITEM_SUBTITLE, getText(R.string.example_cubes_subtitle));

      data.add(item);

      activityMapping.put(i++, CubesActivity.class);

   }

   {

      final Map<String, Object> item = new HashMap<String, Object>();

      item.put(ITEM_IMAGE, R.drawable.icon_example_matrix3d);

      item.put(ITEM_TITLE, (i+1)+". "+getText(R.string.example_effects3d));

      item.put(ITEM_SUBTITLE, getText(R.string.example_effects3d_subtitle));

      data.add(item);

      activityMapping.put(i++, Effects3DActivity.class);

   }

   final SimpleAdapter dataAdapter = new SimpleAdapter(this, data, R.layout.toc_item, new String[] {ITEM_IMAGE, ITEM_TITLE, ITEM_SUBTITLE}, new int[] {R.id.Image, R.id.Title, R.id.SubTitle});

   setListAdapter(dataAdapter);  

   getListView().setOnItemClickListener(new OnItemClickListener() 

     {

     @Override

     public void onItemClick(AdapterView<?> parent, View view, int position, long id) 

      {

      final Class<? extends Activity> activityToLaunch = activityMapping.get(position);

      if (activityToLaunch != null)

        {

        final Intent launchIntent = new Intent(TableOfContents.this, activityToLaunch);

        startActivity(launchIntent);

        }            

      }

     });

   }  

  }

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

package org.distorted.examples.bean;

import org.distorted.library.Distorted;

import android.app.Activity;

import android.os.Bundle;

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

public class BeanActivity extends Activity 

{

    private BeanSurfaceView mView;

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

    @Override

    protected void onCreate(Bundle icicle) 

      {

      super.onCreate(icicle);

      mView = new BeanSurfaceView(this);

      setContentView(mView);

      }

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

    @Override

    protected void onPause() 

      {

      mView.onPause();  

      super.onPause();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      mView.onResume();

      }

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

    @Override

    protected void onDestroy() 

      {

      Distorted.onDestroy();  

      super.onDestroy();

      }

}

package org.distorted.examples.bean;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import org.distorted.examples.R;

import org.distorted.library.Interpolator2D;

import org.distorted.library.Distorted;

import org.distorted.library.DistortedBitmap;

import org.distorted.library.Float2D;

import org.distorted.library.Float4D;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

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

class BeanRenderer implements GLSurfaceView.Renderer 

{

   private GLSurfaceView mView;

   private DistortedBitmap mBean;

   private Float2D pLeft, pRight;

   private Interpolator2D iLeft, iRight;

   private Float4D rLeft, rRight;

   private int bmpHeight, bmpWidth;

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

   public BeanRenderer(GLSurfaceView v) 

      {

      mView = v;

      pLeft = new Float2D(100, 199);

      pRight= new Float2D(230, 150);

      rLeft = new Float4D(-9,-31,35,35);

      rRight= new Float4D(-9,-31,35,35);

      iLeft = new Interpolator2D();

      iRight= new Interpolator2D();

      iLeft.setCount(0.0f);

      iRight.setCount(0.0f);

      iLeft.setDuration(1500);

      iRight.setDuration(1500);

      Float2D p1 = new Float2D(0,0);

      Float2D p2 = new Float2D(-10,-34);

      iLeft.add(p1);

      iLeft.add(p1);

      iLeft.add(p1);

      iLeft.add(p1);

      iLeft.add(p2);

      iLeft.add(p2);

      iRight.add(p1);

      iRight.add(p2);

      iRight.add(p2);

      iRight.add(p1);

      iRight.add(p1);

      iRight.add(p1);

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

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

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

      mBean.draw(System.currentTimeMillis());

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height) 

      { 

      mBean.abortAllEffects(Distorted.TYPE_MATR);  

      if( bmpHeight/bmpWidth > height/width )

        {

        int w = (height*bmpWidth)/bmpHeight;

        mBean.move((width-w)/2 ,0, 0);

        mBean.scale((float)height/bmpHeight);

        }

      else

        {

        int h = (width*bmpHeight)/bmpWidth;

        mBean.move(0 ,(height-h)/2, 0);

        mBean.scale((float)width/bmpWidth);

        }

      Distorted.onSurfaceChanged(width, height); 

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      InputStream is = mView.getContext().getResources().openRawResource(R.raw.bean);

      Bitmap bitmap;

      try 

        {

        bitmap = BitmapFactory.decodeStream(is);

        } 

      finally 

        {

        try 

          {

          is.close();

          } 

        catch(IOException e) { }

        }  

      bmpHeight = bitmap.getHeight();

      bmpWidth  = bitmap.getWidth();

      mBean = new DistortedBitmap(bitmap, 10);     

      mBean.distort(iLeft , rLeft , pLeft );

      mBean.distort(iRight, rRight, pRight);

      try

        {

        Distorted.onSurfaceCreated(mView);

        }

      catch(Exception ex)

        {

        android.util.Log.e("Bean", ex.getMessage() );

        }

      }

}

package org.distorted.examples.bean;

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.os.Build;

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

class BeanSurfaceView extends GLSurfaceView 

{

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

    public BeanSurfaceView(Context context) 

      {

      super(context);

      setEGLContextClientVersion(2);

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

        { 

        setEGLConfigChooser(8, 8, 8, 8, 16, 0);   

        }

      setRenderer(new BeanRenderer(this));

      }

}

package org.distorted.examples.check;

import org.distorted.library.Distorted;

import org.distorted.examples.R;

import android.app.Activity;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.widget.NumberPicker;

import android.widget.NumberPicker.OnValueChangeListener;

import android.view.View;

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

public class CheckActivity extends Activity

{

    private NumberPicker mVPicker, mFPicker;

    private static int maxV, maxF;

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

    @Override

    protected void onCreate(Bundle icicle) 

      {

      super.onCreate(icicle);

      setContentView(R.layout.check1layout);

      mVPicker = (NumberPicker)findViewById(R.id.check1NumberPickerVertex);

      mFPicker = (NumberPicker)findViewById(R.id.check1NumberPickerFragment);

      mVPicker.setMaxValue(1000);

      mVPicker.setMinValue(   0);

      mFPicker.setMaxValue(1000);

      mFPicker.setMinValue(   0);

      mVPicker.setOnValueChangedListener(new OnValueChangeListener() 

         {

         @Override

         public void onValueChange(NumberPicker picker, int oldVal, int newVal) 

           { 

           maxV = newVal;

           }

         });

      mFPicker.setOnValueChangedListener(new OnValueChangeListener() 

         {

         @Override

         public void onValueChange(NumberPicker picker, int oldVal, int newVal) 

           { 

           maxF = newVal;

           }

         });

      }

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

    @Override

    protected void onPause() 

      {

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.checkSurfaceView);

      if( mView!=null ) mView.onPause();

      super.onPause();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.checkSurfaceView);

      if( mView!=null ) mView.onResume();    

      }

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

    @Override

    protected void onDestroy() 

      {

      Distorted.onDestroy();  

      super.onDestroy();

      }

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

    @Override

    public void onWindowFocusChanged(boolean hasFocus) 

      {

      super.onWindowFocusChanged(hasFocus);

      mVPicker.setValue(1);

      mFPicker.setValue(1);

      }

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

    public static int getMaxV()

      {

      return maxV;

      }

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

    public static int getMaxF()

      {

      return maxF;

      }

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

    public void Check(View v)

      {

      setContentView(R.layout.check2layout);

      }     

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

}

package org.distorted.examples.check;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import org.distorted.examples.R;

import org.distorted.library.Distorted;

import org.distorted.library.DistortedBitmap;

import org.distorted.library.Float2D;

import org.distorted.library.Float3D;

import android.app.AlertDialog;

import android.content.Context;

import android.content.DialogInterface;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

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

class CheckRenderer implements GLSurfaceView.Renderer 

{

    private GLSurfaceView mView;

    private DistortedBitmap mSuccess;

    private Float2D pUp, pDown;

    private Float3D vUp, vDown;

    private int bmpHeight, bmpWidth;

    public static String compilationResult;

    public static String compilationTitle;

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

    public CheckRenderer(GLSurfaceView view) 

      { 

      mView = view;

      Distorted.setMaxVertex(CheckActivity.getMaxV());

      Distorted.setMaxFragment(CheckActivity.getMaxF());

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

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

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

      mSuccess.draw(System.currentTimeMillis());

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height) 

      { 

      mSuccess.abortAllEffects(Distorted.TYPE_MATR);  

      if( bmpHeight/bmpWidth > height/width )

        {

        int w = (height*bmpWidth)/bmpHeight;

        mSuccess.move((width-w)/2 ,0, 0);

        mSuccess.scale((float)height/bmpHeight);

        }

      else

        {

        int h = (width*bmpHeight)/bmpWidth;

        mSuccess.move(0 ,(height-h)/2, 0);

        mSuccess.scale((float)width/bmpWidth);

        }

      Distorted.onSurfaceChanged(width, height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {  

      InputStream is = mView.getContext().getResources().openRawResource(R.raw.success);

      Bitmap bitmap;

      try 

        {

        bitmap = BitmapFactory.decodeStream(is);

        } 

      finally 

        {

        try 

          {

          is.close();

          } 

        catch(IOException e) { }

        }  

      bmpHeight = bitmap.getHeight();

      bmpWidth  = bitmap.getWidth();

      pDown = new Float2D(bmpWidth/2,        0);

      pUp   = new Float2D(bmpWidth/2,bmpHeight);

      vUp   = new Float3D( 0,+bmpHeight,0);

      vDown = new Float3D( 0,-bmpHeight,0);

      mSuccess = new DistortedBitmap(bitmap, 30);  

      mSuccess.deform(  vUp,   pUp, 2000, 0.0f);

      mSuccess.deform(vDown, pDown, 2000, 0.0f);

      try

        {

        Distorted.onSurfaceCreated(mView);

        }

      catch(Exception ex)

        {

        compilationTitle = ex.getClass().getSimpleName();

        compilationResult= ex.getMessage();

        String ver;

        ver = GLES20.glGetString(GLES20.GL_SHADING_LANGUAGE_VERSION);   

        compilationResult += "\n\nGLSL version: "+(ver==null ? "null" : ver);

        ver = GLES20.glGetString(GLES20.GL_VERSION);  

        compilationResult += "\nGL version: "+(ver==null ? "null" : ver);

        ver = GLES20.glGetString(GLES20.GL_VENDOR);   

        compilationResult += "\nGL vendor: "+(ver==null ? "null" : ver);

        ver = GLES20.glGetString(GLES20.GL_RENDERER);    

        compilationResult += "\nGL renderer: "+(ver==null ? "null" : ver);

        CheckActivity act = (CheckActivity)mView.getContext();

        act.runOnUiThread(new Runnable() 

          {

          public void run() 

            {

            Context context = mView.getContext();

            AlertDialog.Builder builder = new AlertDialog.Builder(context);

            builder.setTitle(compilationTitle);

            builder.setMessage(compilationResult);

            builder.setCancelable(true);

            builder.setOnCancelListener(new DialogInterface.OnCancelListener() 

              {

              @Override

              public void onCancel(DialogInterface dialog) 

                {

                ((CheckActivity)mView.getContext()).finish();

                }

              });

            AlertDialog alert = builder.create();

            alert.show();

            }

          });

        }

      }

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

}

package org.distorted.examples.check;

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.os.Build;

import android.util.AttributeSet;

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

class CheckSurfaceView extends GLSurfaceView 

{

    private CheckRenderer renderer;

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

    public CheckSurfaceView(Context c, AttributeSet attrs) 

      {

      super(c, attrs);

      if(!isInEditMode())

        {

        setEGLContextClientVersion(2);

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

          { 

          setEGLConfigChooser(8, 8, 8, 8, 16, 0);   

          }

        renderer = new CheckRenderer(this);

        setRenderer(renderer);

        }

      }

}

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

package org.distorted.examples.cubes;

import org.distorted.library.Distorted;

import org.distorted.examples.R;

import android.app.Activity;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.view.Gravity;

import android.view.View;

import android.widget.Button;

import android.widget.LinearLayout;

import android.widget.NumberPicker;

import android.widget.NumberPicker.OnValueChangeListener;

import android.widget.TableRow;

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

public class CubesActivity extends Activity implements View.OnClickListener

{

    private static int mNumCols = 3;

    private static int mNumRows = 3;

    private static final int COLOR_OFF = 0xffffe81f;

    private static final int COLOR_ON  = 0xff0000ff;

    private NumberPicker mColsPicker, mRowsPicker;

    private LinearLayout mLay;

    private static boolean[] mShape;

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

    @Override

    protected void onCreate(Bundle savedState) 

      {

      super.onCreate(savedState);

      setContentView(R.layout.cubes1layout);

      mLay = (LinearLayout)findViewById(R.id.buttongrid);

      mColsPicker = (NumberPicker)findViewById(R.id.colsPicker);

      mRowsPicker = (NumberPicker)findViewById(R.id.rowsPicker);

      mColsPicker.setMaxValue(10);

      mColsPicker.setMinValue( 0);

      mRowsPicker.setMaxValue(10);

      mRowsPicker.setMinValue( 0);

      mColsPicker.setOnValueChangedListener(new OnValueChangeListener() 

         {

         @Override

         public void onValueChange(NumberPicker picker, int oldVal, int newVal) 

           { 

           setGrid();

           }

         });

      mRowsPicker.setOnValueChangedListener(new OnValueChangeListener() 

         {

         @Override

         public void onValueChange(NumberPicker picker, int oldVal, int newVal) 

           { 

           setGrid();

           }

         });

      }

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

    public static int getCols()

      {

      return mNumCols; 

      }

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

    public static String getShape()

      {

      String str = ""; 

      for(int i=0; i<mNumRows*mNumCols; i++)

        str += mShape[i] ? "1" : "0";

      //android.util.Log.d("CUBES", str);

      return str; 

      }

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

    public void setGrid()

      {

      mNumCols = mColsPicker.getValue();

      mNumRows = mRowsPicker.getValue();

      int width = mLay.getWidth();

      int height= mLay.getHeight();

      int w = mNumCols>0 ? (width / mNumCols) -10 : 0;

      int h = mNumRows>0 ? (height/ mNumRows) -10 : 0;

      int size= w<h ? w:h;

      int pad = size/20;

      mLay.removeAllViews();

      mShape = new boolean[mNumRows*mNumCols];

      TableRow.LayoutParams p = new android.widget.TableRow.LayoutParams();

      p.rightMargin  = pad;

      p.leftMargin   = pad;

      p.topMargin    = pad;

      p.bottomMargin = pad;

      p.height       = size;

      p.width        = size;

      for (int rows=0; rows<mNumRows; rows++) 

        {

        TableRow tr = new TableRow(this);

        tr.setGravity(Gravity.CENTER);

        for(int cols=0; cols<mNumCols; cols++) 

          {

          Button b = new Button(this);

          b.setOnClickListener(this);

          b.setId(rows*mNumCols+cols);

          b.setLayoutParams(p);          

          b.setBackgroundColor(COLOR_OFF);

          tr.addView(b, p);

          mShape[rows*mNumCols+cols] = false;

          }

        mLay.addView(tr);

        }

      }

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

    public void onClick(View view) 

      {

      Button tmp = (Button)view;  

      int id = tmp.getId();

      mShape[id] = !mShape[id];

      tmp.setBackgroundColor(mShape[id] ? COLOR_ON:COLOR_OFF);

      }

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

    @Override

    public void onWindowFocusChanged(boolean hasFocus) 

      {

      super.onWindowFocusChanged(hasFocus);

      mColsPicker.setValue(mNumCols);

      mRowsPicker.setValue(mNumRows);

      if( hasFocus ) setGrid();

      }

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

    @Override

    protected void onPause() 

      {

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.cubesSurfaceView);

      if( mView!=null ) mView.onPause();

      super.onPause();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.cubesSurfaceView);

      if( mView!=null ) mView.onResume();  

      }

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

    @Override

    protected void onDestroy() 

      {

      Distorted.onDestroy();  

      super.onDestroy();

      }

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

    public void Continue(View v)

      {   

      setContentView(R.layout.cubes2layout);

      }     

}

package org.distorted.examples.cubes;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import org.distorted.examples.R;

import org.distorted.library.InterpolatorQuat;

import org.distorted.library.DistortedCubes;

import org.distorted.library.Float4D;

import org.distorted.library.Float3D;

import org.distorted.library.Distorted;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

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

class CubesRenderer implements GLSurfaceView.Renderer 

{

	private static final int SIZE = 100;

	private int mCols, mRows;

    private GLSurfaceView mView;

    private DistortedCubes mCubes;

    private InterpolatorQuat mQuatInt1, mQuatInt2;

    Float4D mQuat1, mQuat2;

    int mScreenMin;

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

    public CubesRenderer(GLSurfaceView v) 

      {

      mView = v;

      String shape = CubesActivity.getShape();

      mCols = CubesActivity.getCols();

      mRows = shape.length() / mCols;

      mCubes = new DistortedCubes( mCols, shape, SIZE);

      mQuat1 = new Float4D(0,0,0,1);  // unity

      mQuat2 = new Float4D(0,0,0,1);  // quaternions

      mQuatInt1 = new InterpolatorQuat();

      mQuatInt2 = new InterpolatorQuat();

      mQuatInt1.setDuration(0);

      mQuatInt2.setDuration(0);

      mQuatInt1.setCount(0.5f);

      mQuatInt2.setCount(0.5f);

      mQuatInt1.add(mQuat1);

      mQuatInt2.add(mQuat2);

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

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

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

      mCubes.draw(System.currentTimeMillis());

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height) 

      {

      mScreenMin = width<height ? width:height;

      mCubes.abortAllEffects(Distorted.TYPE_MATR);  

      if( mRows/mCols > height/width )

        {

        int w = (height*mRows)/mCols;

        mCubes.move((width-w)/2 ,0, 0);

        mCubes.scale((float)height/(mRows*SIZE));

        }  

      else

        {   

        int h = (width*mRows)/mCols;

        mCubes.move(0 ,(height-h)/2, 0);

        mCubes.scale((float)width/(mCols*SIZE));

        }

      Float3D center = new Float3D(mCols*SIZE/2,mRows*SIZE/2, 0);

      mCubes.quaternion(center, mQuatInt1);

      mCubes.quaternion(center, mQuatInt2);

      Distorted.onSurfaceChanged(width, height); 

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      InputStream is = mView.getContext().getResources().openRawResource(R.raw.grid);

      Bitmap bitmap;

      try 

        {

        bitmap = BitmapFactory.decodeStream(is);

        } 

      finally 

        {

        try 

          {

          is.close();

          } 

        catch(IOException e) { }

        }  

      mCubes.setBitmap(bitmap);

      try

        {

        Distorted.onSurfaceCreated(mView);

        }

      catch(Exception ex)

        {

        android.util.Log.e("Cubes", ex.getMessage() );

        }

      }

}

package org.distorted.examples.cubes;

import org.distorted.examples.R;

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.os.Build;

import android.util.AttributeSet;

import android.view.MotionEvent;

import android.widget.Toast;

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

class CubesSurfaceView extends GLSurfaceView 

{

    int mX, mY;

    CubesRenderer mRenderer;

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

    public CubesSurfaceView(Context c, AttributeSet attrs) 

      {

      super(c,attrs);

      mX = -1;

      mY = -1;

      if(!isInEditMode())

        {

        setEGLContextClientVersion(2);

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

          { 

          setEGLConfigChooser(8, 8, 8, 8, 16, 0);   

          }

        mRenderer = new CubesRenderer(this);

        setRenderer(mRenderer);

        Toast.makeText(c, R.string.example_cubes_toast , Toast.LENGTH_SHORT).show();   

        }

      }

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

    @Override public boolean onTouchEvent(MotionEvent event) 

      {

      int action = event.getAction();

      int x = (int)event.getX();

      int y = (int)event.getY();

      switch(action)

         {

         case MotionEvent.ACTION_DOWN: mX = x;

                                       mY = y;

                                       break;

         case MotionEvent.ACTION_MOVE: if( mX>=0 && mY>= 0 )

                                         {

                                         float px = mY-y;

                                         float py = mX-x;

                                         float pz = 0;

                                         float plen = (float)Math.sqrt(px*px + py*py + pz*pz);

                                         if( plen>0 )

                                           {

                                           px /= plen;

                                           py /= plen;

                                           pz /= plen;

                                           float cosA = (float)Math.cos(plen*3.14f/mRenderer.mScreenMin);

                                           float sinA = (float)Math.sqrt(1-cosA*cosA);

                                           mRenderer.mQuat1.set(px*sinA, py*sinA, pz*sinA, cosA);

                                           }

                                         }                             

                                       break;

         case MotionEvent.ACTION_UP  : mX = -1;

                                       mY = -1;

                                       float qx = mRenderer.mQuat1.getX();

                                       float qy = mRenderer.mQuat1.getY();

                                       float qz = mRenderer.mQuat1.getZ();

                                       float qw = mRenderer.mQuat1.getW();

                                       float rx = mRenderer.mQuat2.getX();

                                       float ry = mRenderer.mQuat2.getY();

                                       float rz = mRenderer.mQuat2.getZ();

                                       float rw = mRenderer.mQuat2.getW();

                                       float tx = rw*qx - rz*qy + ry*qz + rx*qw;

                                       float ty = rw*qy + rz*qx + ry*qw - rx*qz;

                                       float tz = rw*qz + rz*qw - ry*qx + rx*qy;

                                       float tw = rw*qw - rz*qz - ry*qy - rx*qx;

                                       mRenderer.mQuat1.set(0f, 0f, 0f, 1f);

                                       mRenderer.mQuat2.set(tx, ty, tz, tw);

                                       break;

         }

      return true;

      }

}

package org.distorted.examples.deform;

import org.distorted.library.Distorted;

import org.distorted.examples.R;

import android.app.Activity;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.view.View;

import android.widget.RadioButton;

import android.widget.SeekBar;

import android.widget.TextView;

import android.widget.SeekBar.OnSeekBarChangeListener;

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

public class DeformActivity extends Activity implements OnSeekBarChangeListener

{

    private SeekBar barR;

    private TextView textR;

    private RadioButton effect;

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

    @Override

    protected void onCreate(Bundle icicle) 

      {

      super.onCreate(icicle);

      setContentView(R.layout.deformlayout);

      barR = (SeekBar)findViewById(R.id.deformSeekRadius);

      barR.setOnSeekBarChangeListener(this); 

      textR = (TextView)findViewById(R.id.deformTextRadius);

      barR.setProgress(50);

      textR.setText("Radius: 50");

      effect = (RadioButton)findViewById(R.id.deformDistortButton);

      effect.setChecked(true);

      DeformRenderer.setMode(DeformRenderer.MODE_DISTORT);

      }

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

    @Override

    protected void onPause() 

      {

      DeformRenderer.onPause();

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.deformSurfaceView);

      mView.onPause();

      super.onPause();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      GLSurfaceView mView = (GLSurfaceView) this.findViewById(R.id.deformSurfaceView);

      mView.onResume();

      }

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

    @Override

    protected void onDestroy() 

      {

      android.util.Log.e("activity","onDestroy");  

      Distorted.onDestroy();  

      super.onDestroy();

      }

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

    public void Distort(View v)

      {

      DeformRenderer.setMode(DeformRenderer.MODE_DISTORT);

      }     

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

    public void Deform(View v)

      {

      DeformRenderer.setMode(DeformRenderer.MODE_DEFORM);

      }       

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

    public void Shear(View v)

      {

      DeformRenderer.setMode(DeformRenderer.MODE_SHEAR);

      }       

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

    public void onProgressChanged(SeekBar bar, int progress, boolean fromUser) 

      {

      switch (bar.getId()) 

        {

        case R.id.deformSeekRadius: DeformRenderer.setRegionRadius(progress);

                              textR.setText("Radius: "+progress);

                              break;

        }

      }

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

    public void onStartTrackingTouch(SeekBar bar) { }

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

    public void onStopTrackingTouch(SeekBar bar)  { }

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

}

package org.distorted.examples.deform;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import org.distorted.library.Distorted;

import org.distorted.library.DistortedBitmap;

import org.distorted.library.Interpolator2D;

import org.distorted.library.Float3D;

import org.distorted.library.Float4D;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Paint.Style;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

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

class DeformRenderer implements GLSurfaceView.Renderer 

{

   public static final int MODE_DISTORT= 0;

   public static final int MODE_DEFORM = 1;

   public static final int MODE_SHEAR  = 2;

   private static final int NUM_VECTORS = 8;