Distorted Android

      super.onCreate(savedState);

      setContentView(R.layout.aroundtheworldlayout);

      AroundTheWorldEffectsManager    mana = view.getManager();

      AroundTheWorldRendererPicker    renp = pick.getRenderer();

    @Override

    protected void onPause() 

      {

      view.onPause();

      Distorted.onPause();

      super.onPause();

      {

      super.onResume();

      view.onResume();

      }

      {

      super.onSaveInstanceState(savedInstanceState);

      savedInstanceState.putFloat("x", pick.getx() );

      savedInstanceState.putFloat("y", pick.gety() );

      {

      super.onRestoreInstanceState(savedInstanceState);

      float x = savedInstanceState.getFloat("x");

      float y = savedInstanceState.getFloat("y");

    // WHITENESS

    // Vertex Effects

    wLipsRegion = new Static4D(0,0,0,100);

    wLipsFactor = new Static1D(0.7f);

    wLipsDyn    = new Dynamic1D();

    wLipsDyn.add(wLipsFactor);

    // ASIANNESS

    // Vertex Effects

    aLipsNoseRegion    = new Static4D(0,0,0,267);

    aLipsNoseDyn       = new Dynamic3D();

    aLipsNoseFactor    = new Static3D(0,0,0);

    aLipsNoseDyn.add(aLipsNoseFactor);

    aNoseBroaderRegion = new Static4D(0,0,0,130);

    aNoseBroaderDyn    = new Dynamic2D();

    aNoseBroaderFactor = new Static2D(0,90);

    aNoseBroaderDyn.add(aNoseBroaderFactor);

    aNostrilsRegion    = new Static4D(0,0,0,60);

    aNostrilsDyn       = new Dynamic3D();

    aNostrilsFactor    = new Static3D(0,0,0);

    aNostrilsDyn.add(aNostrilsFactor);

    aEyesRegion        = new Static4D(0,0,0,83);

    aLEyeDyn           = new Dynamic1D();

    aREyeDyn           = new Dynamic1D();

    aLEyeFactor        = new Static1D(0);

    aREyeDyn.add(aREyeFactor);

    aEyebrowsRegion    = new Static4D(0,0,0,142);

    aEyebrowsDyn       = new Dynamic3D();

    aEyebrowsFactor    = new Static3D(0,0,0);

    aEyebrowsDyn.add(aEyebrowsFactor);

    // Fragment Effects

    aSkinColorCenter   = new Static3D(300,300,0);

    aSkinColorRegion   = new Static3D(600,600,600);

    aLEyeColorRegion   = new Static3D(29,25,25);

    aREyeColorRegion   = new Static3D(29,25,25);

    aChromaSkin        = new Static3D(0.5f, 0.5f, 0.5f);

    bFaceDyn.add(bFaceFactor);

    bTipLowerRegion    = new Static4D(0,0,0,41);

    bTipLowerFactor    = new Static3D(0,0,0);

    bTipLowerDyn       = new Dynamic3D();

    bTipLowerDyn.add(bTipLowerFactor);

    bWholeNoseRegion   = new Static4D(0,0,0,130);

    bWholeNoseFactor   = new Static2D(1.0f,90.0f);

    bWholeNoseDyn      = new Dynamic2D();

    bWholeNoseDyn.add(bWholeNoseFactor);

    bNoseBroaderRegion = new Static4D(0,0,0,95);

    bNoseBroaderFactor = new Static2D(1.0f,90.0f);

    bNoseBroaderDyn    = new Dynamic2D();

    bNoseBroaderDyn.add(bNoseBroaderFactor);

    bLipsFactor        = new Static2D(1.0f,0.0f);

    bLipsDyn           = new Dynamic2D();

    bLipsDyn.add(bLipsFactor);

    // Fragment Effects

    bSkinColorCenter     = new Static3D(300,300,0);

    bSkinColorRegion     = new Static3D(600,600,600);

    bLEyeColorRegion     = new Static3D(55,24,50);

    bREyeColorRegion     = new Static3D(55,24,50);

    bLPupilColorRegion   = new Static3D(28,23,25);

    bRPupilColorRegion   = new Static3D(28,23,25);

    bChromaSkin        = new Static3D(0.4f, 0.25f, 0.25f);

    wLipsFactor.set(1.0f-0.3f*mWhiteness);

    // ASIANNESS

    aNoseBroaderFactor.set1(1.0f+0.85f*mAsianness);

    aLEyeFactor.set(+10.0f*mAsianness);

    aREyeFactor.set(-10.0f*mAsianness);

    aChromaSkinFactor.set(0.2f*mAsianness);

    aChromaEyesFactor.set(0.7f*mAsianness);

    // BLACKNESS

    bFaceFactor.set1(1.0f + 0.1f*mBlackness);

    bWholeNoseFactor.set1(1.0f+0.5f*mBlackness);

    bNoseBroaderFactor.set1(1.0f+0.38f*mBlackness);

    bLipsFactor.set1(1.0f+1.0f*mBlackness);

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

      {

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

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

      {

      mView = v;

      Dynamic3D dynLeft   = new Dynamic3D(2000,0.0f);

      Dynamic3D dynRight  = new Dynamic3D(2000,0.0f);

      mMove = new Static3D(0,0,0);

      mScale= new Static3D(1,1,1);

      mEffects = new DistortedEffects();

      mEffects.apply( new VertexEffectDistort(dynLeft , pointLeft , regionLeft) );

      mEffects.apply( new VertexEffectDistort(dynRight, pointRight, regionRight));

      mEffects.apply( new MatrixEffectScale(mScale) );

      mScreen = new DistortedScreen();

     if( mTexture==null ) mTexture = new DistortedTexture(mObjWidth,mObjHeight);

     mTexture.setTexture(bitmap);

     if( mMesh==null ) mMesh = new MeshFlat(25,25*mObjHeight/mObjWidth);

     mScreen.detachAll();

     mScreen.attach(mTexture,mEffects,mMesh);

      {

      super.onCreate(icicle);

      setContentView(R.layout.blurlayout);

      bar.setOnSeekBarChangeListener(this);

      bar.setProgress(50);

      }

    @Override

    protected void onPause() 

      {

      view.onPause();

      Distorted.onPause();

      super.onPause();

    protected void onResume() 

      {

      super.onResume();

      view.onResume();

      }

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

      {

      switch (bar.getId()) 

        {

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

      moveDyn.add(mMove);

      moveDyn.add(new Static3D(0,0,0));

      Static3D chromaRegion= new Static3D( 100, 100, 100 );

      Static3D alphaRegion = new Static3D( 100, 100, 100 );

      Dynamic1D chromaDyn = new Dynamic1D(3000,0.0f);

        }

      catch(Exception ex)

        {

        }

      }

}

      super.onCreate(icicle);

      setContentView(R.layout.check1layout);

      mVPicker.setMaxValue(1000);

      mVPicker.setMinValue(   0);

    @Override

    protected void onPause() 

      {

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

      Distorted.onPause();

      {

      super.onResume();

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

      }

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

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

      mScreen.resize(width,height);

      }

      mSwirl1.set (          0, mObjHeight/2, 0);

      mSwirl2.set (mObjWidth  , mObjHeight/2, 0);

      mDeform1.set(          0,         0   , 0);

      mCenter.set (mObjWidth/2,         0   , 0);

      try

      super.onCreate(savedState);

      setContentView(R.layout.deformlayout);

      barR.setOnSeekBarChangeListener(this);

      if( savedState==null )

        {

        barR.setProgress(50);

        effect.setChecked(true);

        Distort(null);

        }

    @Override

    protected void onPause() 

      {

      Distorted.onPause();

      view.onPause();

      {

      super.onResume();

      view.onResume();

      }

    public void Distort(View v)

      {

      view.getRenderer().setMode(EffectName.DISTORT);

      mCurrEffect = EffectName.DISTORT;

      }     

    public void Deform(View v)

      {

      view.getRenderer().setMode(EffectName.DEFORM);

      mCurrEffect = EffectName.DEFORM;

      }       

    public void Shear(View v)

      {

      view.getRenderer().setMode(EffectName.SHEAR);

      mCurrEffect = EffectName.SHEAR;

      }       

      {

      switch (bar.getId()) 

        {

                                    view.getRenderer().setRegionRadius(progress);

                                    textR.setText(getString(R.string.radius_placeholder,(progress<100 ? (""+progress): "Infinity") ));

                                    break;

      mView = view;

      stretchEffects = new DistortedEffects();

      // DISTORT

      Dynamic3D releasedDistortDynamic = new Dynamic3D(NUM_VECTORS*500, 0.5f);

      mScreen = new DistortedScreen();

      mScreen.showFPS();

      stretchEffects.apply(new MatrixEffectMove(mMove));

      }

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

       {

       }

     if( stretchTexture==null ) stretchTexture = new DistortedTexture(w,h);

   void down(int x, int y)

     {

     int yt = y-scrHeight/4;

     if( xt<0 ) xt=0;

     if( yt<0 ) yt=0;

     if( yt>scrHeight/2 ) yt=scrHeight/2;

     switch(mMode)

       {

     {

     switch(mMode)

       {

                     break;

                     break;

                     break;

       }

     }

      Dynamic3D dDistort = new Dynamic3D(3000,0.0f);

      dDistort.add(new Static3D( 25,0,0));

      dDistort.add(new Static3D(-25,0,0));

      mEffects = new DistortedEffects[NUM];

      mEffects[0] = new DistortedEffects();

      // Add the effects only to the first queue - all VERTEX and FRAGMENT effects are shared!

      // (Matrix effect cannot be shared as we have to display each Texture in a different location)

      VertexEffectDistort distort = new VertexEffectDistort(dDistort,mPoint);

      mEffects[0].apply(sink);    // enlarge the nose

      mEffects[0].apply(distort); // keep moving the whole bitmap left and right.

   private Bitmap readBitmap(int id)

     {

     InputStream is = mView.getContext().getResources().openRawResource(id);

     try 

       {

      mView = v;

      // mEffects[0] effects

      Static4D RegionEye = new Static4D(0,0,0,60);

      // mEffects[1] effects

      Dynamic3D dyn = new Dynamic3D(1000,0.0f);

      dyn.add(new Static3D( 50,0,0));

      dyn.add(new Static3D(-50,0,0));

      // we don't need to prepare anything for mEffects[2] effects

      float factor = xW>xH ? mLevel*xH : mLevel*xW;

      mScaleFactor.set(factor,factor,factor);

      }

      double cosLAT = Math.cos(latitude);

      float x = (float)(sinLON*cosLAT)/2.0f;

      float z = (float)(cosLON*cosLAT)/2.0f;

      Static3D center = new Static3D( (0.5f+x)*mObjWidth, (0.5f+y)*mObjHeight, (0.5f+z)*mObjDepth);

    mPosName = 0;

    mPosType = 0;

    mAdd.setOnItemSelectedListener(this);

    mID.setOnItemSelectedListener(this);

    adapterType.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

    mType.setAdapter(adapterType);

    }

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

    {

    super.onResume();

    mView.onResume();

    }

  @Override

  protected void onPause() 

    {

    mView.onPause();

    Distorted.onPause();

    {

    switch(parent.getId())

      {

                                       v.setEffect(pos); break;

      case R.id.effects2d_spinnerID  : mPosID   = pos; break;

      case R.id.effects2d_spinnerName: mPosName = pos; break;

    try

      {

      Long currEffect = (Long)mID.getItemAtPosition(mPosID);

      v.getRenderer().getEffects().abortById(currEffect);

      }

    catch(IndexOutOfBoundsException ex)

      default: name = EffectName.CONTRAST     ;

      }

    v.getRenderer().getEffects().abortByName(name);

    }

      default: type = EffectType.MATRIX;

      }

    v.getRenderer().getEffects().abortByType(type);

    }

      tr.setLayoutParams(new TableRow.LayoutParams(TableRow.LayoutParams.WRAP_CONTENT, TableRow.LayoutParams.WRAP_CONTENT));

      TextView b1 = new TextView(this);

      b1.setLayoutParams(new TableRow.LayoutParams(TableRow.LayoutParams.WRAP_CONTENT, TableRow.LayoutParams.WRAP_CONTENT));

      tr.addView(b1);

      tr.addView(b3);

      TextView b4 = new TextView(this);

      b4.setLayoutParams(new TableRow.LayoutParams(TableRow.LayoutParams.WRAP_CONTENT, TableRow.LayoutParams.WRAP_CONTENT));

      tr.addView(b4);

        if( row!=null )

          {

          TextView v = (TextView)row.getVirtualChildAt(3);

          }

        }

      });

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

      {

      }

    mTexture.setTexture(bitmap);

import android.view.MotionEvent;

import android.util.AttributeSet;

import org.distorted.library.effect.FragmentEffectAlpha;

import org.distorted.library.effect.FragmentEffectChroma;

import org.distorted.library.effect.FragmentEffectSaturation;

  private int mCurrentEffect;

  private int mScrW, mScrH;

  private Dynamic1D mInterA, mInterB, mInterC, mInterS;

  private Dynamic3D mInterD;

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

      final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

      setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );

      setRenderer(mRenderer);

      }

    }

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

    {

    int x,y,action = event.getAction();

    boolean success;

    switch(action)

      {

                                    EffectQueueActivity act = (EffectQueueActivity)getContext();

                                    switch(mCurrentEffect)

                                      {

                                              break;

                                              break;

                                              break;

                                              break;

                                              break;

                                      }

      mRegionPoint.set(mFactorObj*act.getRegionX(),-mFactorObj*act.getRegionY(),0);

      mFactorReg = 2*mFactorObj*act.getRegionR()/regionSize;

      mRegionScalePoint.set(mFactorReg,mFactorReg,mFactorReg);

      mRotateCen.set(width/2,height/2, 0);

      mScaleObject.set(mFactorObj,mFactorObj,mFactorObj);

      mMoveCenter.set( (width -factorCen*centerSize-mFactorObj*mObjWidth )/2 ,

      mNoise = new Static5D(0,0,0,0,0);

      barAmplitude.setOnSeekBarChangeListener(this);

      barLength.setOnSeekBarChangeListener(this);

      barAngleA.setProgress(25);

      barAngleB.setProgress(1);

      barNoiseAmplitude.setOnSeekBarChangeListener(this);

      barNoiseLength.setOnSeekBarChangeListener(this);

    @Override

    protected void onPause() 

      {

      mView.onPause();

      Distorted.onPause();

      {

      super.onResume();

      mView.onResume();

      }

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

      {

      FlagRenderer renderer = mView.getRenderer();

      switch (bar.getId())

class FlagRenderer implements GLSurfaceView.Renderer

{

    private GLSurfaceView mView;

    private DistortedTexture mTexture;

    private DistortedScreen mScreen;

    private Dynamic5D mWaveDyn;

      {

      mView = v;

      mTexture = new DistortedTexture(500,300);

      mObjWidth = mTexture.getWidth();

      Static3D waveCenter = new Static3D(mObjWidth, mObjHeight/2, 0);  // middle of the right edge

      Static4D waveRegion = new Static4D(0,0,0,mObjWidth);

      mMove  = new Static3D(0,0,0);

      mScale = new Static3D(1,1,1);

      mCenter= new Static3D(0,0,0);

      mScreen = new DistortedScreen();

      }

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

      setContentView(R.layout.girllayout);

      barSwing.setOnSeekBarChangeListener(this); 

      barSize.setOnSeekBarChangeListener(this); 

    @Override

    protected void onPause() 

      {

      view.onPause();

      Distorted.onPause();

      {

      super.onResume();

      view.onResume();

      }

      {

      int v;

      float s;

      switch (bar.getId()) 

        {

      {

      mView = v;

      // Size

      Static4D sinkRegion = new Static4D(0,0,0,60);

      diR.add(v1);

      // Lower Movement

      Static4D HipsRegion = new Static4D(0,0,0,120);

      dBegin = new Static1D(0);

      dMiddle= new Static1D(0);

      mEffects = new DistortedEffects();

      mMove = new Static3D(0,0,0);

      mScale= new Static3D(1,1,1);

   void setSwing(int swing)

     {

     v1.set( swing, 0, 0);

     v3.set(-swing, 0, 0);

     }

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

      {

      mScreenMin = width<height ? width:height;

      mScale.set(factor,factor,factor);

      mCenter.set( (float)mObjWidth/2, (float)mObjHeight/2, (float)mObjDepth/2 );

      mScreen.resize(width, height);

   ListenerRenderer(GLSurfaceView v)

      {

      mView = v;

      mEffects = new DistortedEffects();

      mEffects.registerForMessages(this);

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

      {

      int radius   = (int)(( 0.10f + 0.70f*mRnd.nextFloat())*bmpWidth);           // pop up a bubble of size (radius,height)

      int height   = (int)((-0.10f + 0.20f*mRnd.nextFloat())*bmpWidth);           // 

      int pointx   = mRnd.nextInt( (int)(0.8f*bmpWidth ))+ (int)(0.1f*bmpWidth ); // at a random place on the bitmap (but not near the edge)

      int pointy   = mRnd.nextInt( (int)(0.8f*bmpHeight))+ (int)(0.1f*bmpHeight); // 

      Dynamic3D dDistort = new Dynamic3D(duration,1.0f);

      dDistort.add(new Static3D(0,0,     0));

     {

     switch(em)

        {

        }

     }

     mScreen.detachAll();

     mScreen.attach(mTexture,mEffects,mMesh);

     VertexEffectDistort.enable();

      super.onCreate(icicle);

      setContentView(R.layout.mirrorlayout);

      bar.setOnSeekBarChangeListener(this);

      bar.setProgress(INIT_POSITION);

      }

    @Override

    protected void onPause() 

      {

      view.onPause();

      Distorted.onPause();

    protected void onResume() 

      {

      super.onResume();

      view.onResume();

      view.getRenderer().onResume();

      }

      {

      switch (bar.getId()) 

        {

                              view.getRenderer().setPosition(progress);

                              break;

        }

   private static final float HEAD_SCALE       =0.30f;  // Head's height will be 30% of the height of the mirror

   private static final float MIRROR_BRIGHTNESS=0.70f;  // Each next mirror 30% darker

   private static final float MIRROR_MARGIN    =0.11f;  // The frame of the mirror takes up 11% of its width

                                                        // the length of the previous one

   private GLSurfaceView mView;

   private DistortedEffects mEffectsMirror, mEffectsHead, mEffectsNull;

        mOffScreen2 = new DistortedFramebuffer( (int)(MIRROR_SCALE*mScreenW), (int)(MIRROR_SCALE*mScreenH), 1, DistortedFramebuffer.NO_DEPTH_NO_STENCIL );

        mScaleMirror.set( (float)mScreenW/mMirrorW, (float)mScreenH/mMirrorH, 1.0f);

        float headScale = HEAD_SCALE *mScreenH/ mHeadH;

        mScaleHead.set(headScale,headScale,headScale);

        setPosition(mX);

        mOffScreen1.attach( mTextureMirror, mEffectsMirror    , mQuad );

      {

      mView = v;

      Dynamic3D dLeft = new Dynamic3D(1000,0.0f);

      Dynamic3D dRight= new Dynamic3D(1000,0.0f);

      mEffects = new DistortedEffects();

      mEffects.apply( new VertexEffectDistort(dLeft , pLeft , rLeft ) );

      mScreen.detachAll();

      mScreen.attach(mTexture,mEffects,mMesh);

      VertexEffectDistort.enable();

      try

      setContentView(R.layout.movingeffectslayout);

      mAbort.setBackgroundColor(COLOR_PRESSED);

      mChroma.setBackgroundColor(COLOR_UNPRESSED);

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      view.onResume();

      }

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

    @Override

    protected void onPause() 

      {

      Abort(null);   

      view.onPause();

      Distorted.onPause();

      }

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

    @Override

    public void onStop()

      {

    public void Bubble(View v)

      {

      view.Bubble();

      mAbort.setBackgroundColor(COLOR_UNPRESSED);

    public void Sink(View v)

      {

      view.Sink();

      mAbort.setBackgroundColor(COLOR_UNPRESSED);

    public void Transparency(View v)

      {

      view.Transparency();

      mAbort.setBackgroundColor(COLOR_UNPRESSED);

    public void Chroma(View v)

      {

      view.Chroma();

      mAbort.setBackgroundColor(COLOR_UNPRESSED);

    public void Swirl(View v)

      {

      view.Swirl();

      mAbort.setBackgroundColor(COLOR_UNPRESSED);

    public void Abort(View v)

      {

      view.Abort();

      mAbort.setBackgroundColor(COLOR_PRESSED);

      mBubble.setBackgroundColor(COLOR_UNPRESSED);

      mSwirl.setBackgroundColor(COLOR_UNPRESSED);

      }

}

    private Paint mPaint;

    private int moving;

    private long mTime = 0;

    private int mCurrEffect;

      {

      int max = width>height ? width:height;

      mSize1 = max/200;

      mSize2 = max/80;

      int rad= max/6;

            {

            mPaint.setColor( 0xffffffff );

            mCenter.get( drawCoord, 0, (long)(i*step) );

            }

          }

        for(int curr=0; curr<len; curr++)

          {       

          cu = mCenter.getPoint(curr);

          }

        if( time-mTime > LOOP_TIME ) mTime = time;

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

      {

      if( mCurrEffect!=EFFECT_POINTS ) return true;   

      switch(event.getAction())

        {