Distorted Android

      mView = view;

      mManager = new AroundTheWorldEffectsManager();

      mEffects.apply(new MatrixEffectScale(mScale));

      mEffects.apply(new MatrixEffectMove(mMove));

      mObjWidth = bitmap.getWidth();

      mObjHeight= bitmap.getHeight();

      if( mTexture==null ) mTexture = new DistortedTexture();

      mTexture.setTexture(bitmap);

      mScreen.detachAll();

      mScreen.attach(mTexture, mEffects, mMesh);

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

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

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

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

      mEffects.apply( new MatrixEffectScale(mScale) );

     mObjHeight = bitmap.getHeight();

     mObjWidth  = bitmap.getWidth();

     if( mTexture==null ) mTexture = new DistortedTexture();

     mTexture.setTexture(bitmap);

     mScreen.detachAll();

     mScreen.attach(mTexture,mEffects,mMesh);

    private DistortedEffects mEffects, mBufferEffects;

    private DistortedScreen mScreen;

    private DistortedFramebuffer mBuffer;

    private Static1D mRadiusSta;

    private int mObjHeight, mObjWidth;

    private Static3D mMove, mScale, mBufferMove, mBufferScale;

   BlurRenderer(GLSurfaceView v)

      {

      mRadiusSta = new Static1D(5);

      Dynamic1D radiusDyn = new Dynamic1D();

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

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

      mBufferEffects.apply(new MatrixEffectScale(mBufferScale));

      mBufferEffects.apply(new MatrixEffectMove(mBufferMove));

      mEffects.apply( new PostprocessEffectBlur(radiusDyn) );

      mEffects.apply(new MatrixEffectScale(mScale));

      mEffects.apply(new MatrixEffectMove(mMove));

     mObjHeight = bitmap.getHeight();

     mObjWidth  = bitmap.getWidth();

     if( mTexture==null ) mTexture = new DistortedTexture();

     mTexture.setTexture(bitmap);

     mScreen.detachAll();

     mBuffer.attach(new DistortedNode(mTexture,mEffects,mMesh));

     PostprocessEffectBlur.enable();

      diRotate.add(new Static1D(  0));

      diRotate.add(new Static1D(360));

      mEffects.apply( new MatrixEffectRotate( diRotate, new Static3D(0,0,1), mRotate) );

      mEffects.apply( new MatrixEffectScale(diScale));

      mObjWidth  = bitmap.getWidth();

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

      if( mTexture==null ) mTexture = new DistortedTexture();

      mTexture.setTexture(bitmap);

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

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

      mEffects.apply(new MatrixEffectScale(mScale));

      mEffects.apply(new MatrixEffectMove(mMove));

      mObjHeight = bitmap.getHeight();

      mObjWidth  = bitmap.getWidth();

      if( mTexture==null ) mTexture = new DistortedTexture();

      mTexture.setTexture(bitmap);

      mScreen.detachAll();

      mScreen.attach(mTexture,mEffects,mMesh);

      { 

      mView = view;

      mRegion     = new Static4D(0,0,0,0);

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

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

     int h=height/2;

     if( mMesh!=null ) mMesh.markForDeletion();

     mMesh = new MeshRectangles(50,50*h/w);

     Bitmap stretchBitmap = Bitmap.createBitmap(w,h, Bitmap.Config.ARGB_8888);

     stretchCanvas = new Canvas(stretchBitmap);

       stretchCanvas.drawRect(              0, h*i/NUM_LINES-1, w              , h*i/NUM_LINES+1, paint);

       }

     if( mTexture==null ) mTexture = new DistortedTexture();

     mTexture.setTexture(stretchBitmap);

      Static3D mPoint = new Static3D(305, 220, 0);

      mEffects = new DistortedEffects[NUM];

      for(int i=1; i<NUM; i++)

        mEffects[i] = new DistortedEffects(mEffects[0], DistortedLibrary.CLONE_VERTEX| DistortedLibrary.CLONE_FRAGMENT);

     bmpHeight = bitmap0.getHeight();

     bmpWidth  = bitmap0.getWidth();

     if( mTexture==null )

       {

       mTexture = new DistortedTexture[NUM];

     mTexture[1].setTexture(bitmap1);

     mTexture[2].setTexture(bitmap2);

     mScreen.detachAll();

     for(int i=NUM-1; i>=0; i--) mScreen.attach(mTexture[i], mEffects[i], mMesh);

      mEffects = new DistortedEffects[NUM];

      Dynamic1D sink = new Dynamic1D(2000,0.0f);

      sink.add(new Static1D( 1));

     bmpHeight = bitmap.getHeight();

     bmpWidth  = bitmap.getWidth();

     if( mTexture==null ) mTexture  = new DistortedTexture();

     mTexture.setTexture(bitmap);

     mView    = v;

     mMesh    = new MeshRectangles(1,1);

     mScreen  = new DistortedScreen();

     }

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

     if( mTexture!=null ) mTexture.markForDeletion();

     mTexture= new DistortedTexture();

     mBitmap = Bitmap.createBitmap(texW,texH, Bitmap.Config.ARGB_8888);

     mCanvas = new Canvas(mBitmap);

      scale.add(mScaleFactor);

      mMesh     = new MeshSphere(LEVEL);

      mTexture  = new DistortedTexture();

      mObjWidth = mObjHeight = mObjDepth = SIZE;

      quatInt1.add(mQuat1);

      quatInt2.add(mQuat2);

      mEffects.apply( new MatrixEffectQuaternion(quatInt2, mCenter) );

      mEffects.apply( new MatrixEffectQuaternion(quatInt1, mCenter) );

      mEffects.apply( new MatrixEffectScale(scale));

    MatrixEffectScale scaleEffect = new MatrixEffectScale(mScale);

    mMesh = new MeshRectangles(MESH_QUALITY,MESH_QUALITY*texHeight/texWidth);

    mTexture = new DistortedTexture();

    mEffects.apply(scaleEffect);

    mScreen = new DistortedScreen();

    private DistortedScreen mScreen;

    private Dynamic5D mWaveDyn;

    private Static5D mWaveSta1, mWaveSta2;

    private Static3D mMove, mScale, mCenter;

    Static4D mQuat1, mQuat2;

      final Static4D mapLR = new Static4D(0.0f,0.0f,1.0f/GRIDX,1.0f      );

      final Static4D mapTB = new Static4D(0.0f,0.0f,1.0f      ,1.0f/GRIDY);

      MeshCubes mesh = new MeshCubes(GRIDX,GRIDY,1, mapFB, mapFB, mapLR, mapLR, mapTB, mapTB);

      mTexture = new DistortedTexture();

      mWaveDyn = new Dynamic5D(1000,0.0f);

      mWaveSta1= new Static5D(0,0,-180,0,0);  // all other values besides the

      mWaveSta2= new Static5D(0,0,+180,0,0);  // fourth will be set from the UI

      mQuat1 = new Static4D(           0,         0,           0,          1);  // unity quaternion

      mQuat2 = new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);  // something semi-random that looks good

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

      effects.apply( new VertexEffectWave(mWaveDyn, waveCenter, waveRegion) );

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

      {

      mScreenMin = width<height ? width:height;

      float factor = ( width*mObjHeight > height*mObjWidth ) ? (0.8f*height)/mObjHeight : (0.8f*width)/mObjWidth;

      mScale.set(factor,factor,factor);

      mScreen.resize(width, height);

      }

    mShowNormal = false;

    mUseOIT     = false;

    int maxsize = numCols > numRows ? (numCols>numSlic ? numCols:numSlic) : (numRows>numSlic ? numRows:numSlic) ;

                mMesh = new MeshCubes(numCols, str, numSlic, mapFB, mapFB, mapLR, mapLR, mapTB, mapTB);

                }

              break;

      case 1: mMesh = new MeshRectangles(numCols,numRows);

              break;

      case 2: mMesh = new MeshSphere(numRows);

              break;

      case 3: mMesh = new MeshQuad();

              break;

      }

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

    {

    }

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

    {

    }

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

    {

    }

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

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshSphere;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

    private GLSurfaceView mView;

    private DistortedTexture mObjectTexture, mBackgroundTexture, mCenterTexture, mRegionTexture;

    private DistortedScreen mScreen;

    private DistortedNode mCenterNode, mRegionNode;

    private Static3D mCenterPoint, mRegionPoint, mRegionScalePoint;

    private Static3D mRotateCen, mMoveObject, mScaleObject, mMoveCenter, mScaleCenter, mMoveRegion, mMoveBackground, mScaleBackground;

    private boolean mShowingCenter=false;

      mFactorObj = 1.0f;

      mFactor = mesh instanceof MeshSphere ? 1.0f : 0.7f;

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

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

      mScreen = new DistortedScreen();

      mScreen.setProjection(FOV, NEAR);

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

      MatrixEffectQuaternion quat1cen = new MatrixEffectQuaternion(mQuat1, mRotateCen);

      MatrixEffectQuaternion quat2cen = new MatrixEffectQuaternion(mQuat2, mRotateCen);

      MatrixEffectMove centerMove = new MatrixEffectMove(mCenterPoint);

      resetMatrixEffects();

      // quite tricky: move the background exactly to the FAR plane! (see InternalOutputSurface.setProjection() )

      }

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

    void setRegion(float x, float y, float z, float r)

      {

      mRegionPoint.set(mFactorObj*x,mFactorObj*y, mFactorObj*z);

      mRegionScalePoint.set(factorReg,factorReg,factorReg);

      }

      mScreenMin = width<height ? width:height;

      float factorCen;

      if( width*mObjHeight > height*mObjWidth ) // screen is more 'horizontal' than the Object

        {

      mScaleCenter.set(factorCen,factorCen,factorCen);

      mMoveRegion.set( (width -mFactorObj*mObjWidth )/2 ,(height-mFactorObj*mObjHeight)/2 , 12 );

      float factorBackX = ((float)width)/backgroundSize;

      float factorBackY = ((float)height)/backgroundSize;

package org.distorted.examples.generic;

import android.os.Bundle;

import android.support.v4.app.Fragment;

import android.view.LayoutInflater;

import android.view.View;

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

  @Override

    {

    Bundle args = getArguments();

      diHips.add(dMiddle);

      diHips.add(dBegin);

      mEffects.apply( new VertexEffectSink   ( diSink, pLeft , sinkRegion) );

      mEffects.apply( new VertexEffectSink   ( diSink, pRight, sinkRegion) );

     bmpHeight = bitmap.getHeight();

     bmpWidth  = bitmap.getWidth();

     if( mTexture==null ) mTexture = new DistortedTexture();

     mTexture.setTexture(bitmap);

     mScreen.detachAll();

     mScreen.attach(mTexture,mEffects,mMesh);

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

      mGlow  = new PostprocessEffectGlow(mRadius,mColor);

      effects.apply(new MatrixEffectScale(mScale));

      effects.apply(new MatrixEffectMove(mMove));

      effects.apply(mGlow);

      mScreen = new DistortedScreen();

      mScreen.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

      mScreen.showFPS();

      }

                  mMesh = new MeshCubes(mNumCols, str, mNumSlic, mapFB, mapFB, mapLR, mapLR, mapTB, mapTB);

                  }

                break;

        case 1: mMesh = new MeshRectangles(mNumCols,mNumRows);

                break;

        case 2: mMesh = new MeshSphere(mNumRows);

                break;

        case 3: mMesh = new MeshQuad();

                break;

        }

    private DistortedEffects mEffects;

    private MeshBase mMesh;

    private DistortedScreen mScreen;

    private Static3D mMove, mScale, mCenter;

    private Static1D mAlpha;

      mTexture = act.getTexture();

      mMesh    = act.getMesh();

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

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

      quatInt1.add(mQuat1);

      quatInt2.add(mQuat2);

      mEffects.apply( new MatrixEffectQuaternion(quatInt2, mCenter) );

      mEffects.apply( new MatrixEffectQuaternion(quatInt1, mCenter) );

      mEffects.apply( new MatrixEffectScale(mScale));

     if( mTexture==null ) mTexture = new DistortedTexture();

     mTexture.setTexture(bitmap);

     if( mEffects==null )

       {

       mEffects.apply(new MatrixEffectScale(mScale));

       mEffects.apply(new MatrixEffectMove(mMove));

       }

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

   private DistortedTexture mTextureMirror, mTextureHead;

   private DistortedFramebuffer mOffScreen1, mOffScreen2;

   private DistortedScreen mScreen;

   private Static3D mHeadPosition, mScaleMirror, mMoveOffscreen2, mScaleHead;

   private int mX;

   MirrorRenderer(GLSurfaceView view)

      { 

      mView    = view;

      mScreen  = new DistortedScreen();

      mX = MirrorActivity.INIT_POSITION;

        int offscreen2W = (int)(MIRROR_SCALE*mScreenW);

        int offscreen2H = (int)(MIRROR_SCALE*mScreenH);

        mOffScreen1 = new DistortedFramebuffer( offscreen1W, offscreen1H, 1, DistortedFramebuffer.NO_DEPTH_NO_STENCIL );

        mOffScreen2 = new DistortedFramebuffer( offscreen2W, offscreen2H, 1, DistortedFramebuffer.NO_DEPTH_NO_STENCIL );

        mHeadPosition.set1( mScreenH*MIRROR_MARGIN*mMirrorW/mMirrorH );

        setPosition(mX);

        mScreen.detachAll();

        mScreen.resize(mScreenW,mScreenH);

        }

      }

      mHeadW   = bitmapH.getWidth();

      mHeadH   = bitmapH.getHeight();

      if( mTextureMirror==null ) mTextureMirror = new DistortedTexture();

      if( mTextureHead  ==null ) mTextureHead   = new DistortedTexture();

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

      dRight.add( new Static3D( 20, 10, 0) );

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

      mEffects.apply( new VertexEffectDistort(dRight, pRight, rRight) );

      bmpHeight = bitmap.getHeight();

      bmpWidth  = bitmap.getWidth();

      // This will make the Mesh stretched by bmpWidth x bmpHeight even before any effects

      // are applied to it (the Mesh - MeshRectangles - is flat, so the third parameter does not

      // not matter). bmpWight x bmpHeight is the size of the Bitmap, thus this means that we can

      // around its center has to be centered at (bmpWidth/2, bmpHeight/2, 0).

      // Without this call, the default size of the Mesh is 1x1x0 ( or 1x1x1 in case of not-flat

      // Meshes) so we would need to be rotating around (0.5,0.5,0.0).

      // even if mTexture wasn't null, we still need to call setTexture() on it

      // because every time activity goes to background, its OpenGL resources

     mPaint.setStyle(Style.FILL);

     mView   = v;

     mScreen = new DistortedScreen();

     mRefresh= true;

     }

     mBitmap  = Bitmap.createBitmap(texW,texH, Bitmap.Config.ARGB_8888);

     mCanvas  = new Canvas(mBitmap);

     if( mMesh!=null ) mMesh.markForDeletion();

     mMesh = new MeshRectangles(80,80*texH/texW);

     mScreen.detachAll();

     mScreen.attach(mTexture,mEffects,mMesh);

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

      mLeaf = new DistortedTexture();

      DistortedTexture surface = new DistortedTexture();

      Static3D moveVector = new Static3D(0.55f*LEAF_SIZE, (mRootH-LEAF_SIZE)/2, 0);

      Static1D chromaLevel= new Static1D(0.5f);

      Static3D center     = new Static3D(mRootW/2, mRootH/2, 0);

      for(int j=0; j<NUM_LEAVES; j++)

        {

        mLeafEffects[j].apply(leafMove);

        mLeafEffects[j].apply( new MatrixEffectRotate(new Static1D(j*(360/NUM_LEAVES)), axis, center) );

        mLeafEffects[j].apply( new FragmentEffectChroma(chromaLevel, new Static3D(colors[3*j],colors[3*j+1], colors[3*j+2])) );

        root.attach(node);

        }

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

        {

        mMoveVector[i] = new Static3D(0,0,0);

        mBlurStatus[i] = false;

        }

      mBlurVector = new Static1D(10);

      MeshCubes mesh = new MeshCubes(1,1,1);

      mTex1 = new DistortedTexture();

      mTex2 = new DistortedTexture();

      chromaDyn.add(new Static1D(0.0f));

      chromaDyn.add(new Static1D(0.8f));

      mEffects.apply(new MatrixEffectScale(mScale));

      mEffects.apply(new MatrixEffectMove(mMove));

      mEffects.apply(new FragmentEffectChroma(chromaDyn, new Static3D(0,0,1)));

      int gridHeight= bitmap2.getHeight();

      int gridDepth = gridWidth/GRID;

      if( mLisaTexture==null ) mLisaTexture = new DistortedTexture();

      if( mGridTexture==null ) mGridTexture = new DistortedTexture();

      mLisaTexture.setTexture(bitmap1);

      mGridTexture.setTexture(bitmap2);

      mRoot = new DistortedNode(mLisaTexture, mEffects, mMeshRectangles);

      mRoot.attach(mGridTexture,gridEffects,mMeshCubes);

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static1D;

   private DistortedNode mRoot;

   private DistortedTexture mLeaf;

   private DistortedScreen mScreen;

   private int mScreenW, mScreenH;

   private int mPrevRendered, mCurrRendered;

   private Static3D mMove, mScale;

         }

       else if( number>0 && number<=NUM_LEAVES )

         {

         else          mCircleNode[color].detach(mEffects[number-1]);

         }

       }

      mLeaf = new DistortedTexture();

      DistortedTexture surface = new DistortedTexture();

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

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

      rootEffects.apply(new MatrixEffectScale(mScale));

      rootEffects.apply(new MatrixEffectMove(mMove));

      Dynamic1D rot = new Dynamic1D(5000,0.0f);

      rot.setMode(Dynamic1D.MODE_JUMP);

      for(int j=0; j<NUM_LEAVES; j++)

        {

        mEffects[j].apply(new MatrixEffectMove(moveVector));

        mEffects[j].apply( new MatrixEffectRotate(new Static1D(j*(360/NUM_LEAVES)), axis, center) );

        }

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

        {

        effects.apply( new MatrixEffectRotate(rot, axis, center) );

        effects.apply( new MatrixEffectMove(new Static3D(positions[2*i], positions[2*i+1], 0)) );

        effects.apply( new FragmentEffectChroma(new Static1D(0.5f), new Static3D(colors[3*i],colors[3*i+1], colors[3*i+2])) );

        mRoot.attach(mCircleNode[i]);

        }

      mScreen = new DistortedScreen();

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

    dRight.add( new Static3D( 20, 10, 0) );

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

    mEffects.apply( new VertexEffectDistort(dRight, pRight, rRight) );

    bmpHeight = bmp.getHeight();

    bmpWidth  = bmp.getWidth();

    if( mTexture==null ) mTexture = new DistortedTexture();

    mTexture.setTexture(bmp);

    mScreen.detachAll();

    mScreen.attach(mTexture,mEffects,mMesh);

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

      mLeaf = new DistortedTexture();

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

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

      DistortedEffects[] innerLeafEffects= new DistortedEffects[NUM_LEAVES];

      DistortedEffects[] outerLeafEffects= new DistortedEffects[NUM_LEAVES];

      rootEffects.apply(new MatrixEffectScale(mScale));

      rootEffects.apply(new MatrixEffectMove(mMove));

      for(int j=0; j<NUM_LEAVES; j++)

        {

        outerLeafEffects[j].apply(new MatrixEffectMove(outerMoveVector));

        outerLeafEffects[j].apply( new MatrixEffectRotate(new Static1D(j*(360/NUM_LEAVES)), axis, outerCenter) );

        }

      innerEffects.apply( new MatrixEffectRotate(rotate, axis, innerCenter) );

      innerEffects.apply( new FragmentEffectChroma(new Static1D(0.5f), new Static3D(1,0,0) ) );

      innerEffects.apply(blurEffect);

      root.attach(innerNode);

      for(int j=0; j<NUM_LEAVES; j++)

        {

        innerLeafEffects[j].apply(new MatrixEffectMove(innerMoveVector));

        innerLeafEffects[j].apply( new MatrixEffectRotate(new Static1D(j*(360/NUM_LEAVES)), axis, innerCenter) );

        }

      mScreen = new DistortedScreen();

   ProjectionRenderer(GLSurfaceView view)

      { 

      mView   = view;

      mScreen = new DistortedScreen();

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

      mPoint3.set(  width/4, 3*height/4, 0);

      mPoint4.set(3*width/4, 3*height/4, 0);

      // Avoid memory leaks: delete old texture if it exists (it might if we

      // got here after a brief amount of time spent in the background)

      if( mTexture!=null ) mTexture.markForDeletion();

      mTexture.setTexture(bmp);

      // likewise with the Mesh

      mMesh = new MeshRectangles(100,100*height/width);

      mScreen.detachAll();

      mScreen.attach(mTexture,mEffects,mMesh);

    mView    = v;

    mTexture = new DistortedTexture();

    DynamicQuat rot = new DynamicQuat();

    Random rnd = new Random(System.currentTimeMillis());

              tmpBottom= (y==       0 ? mapBottom:mapBlack);

              mCubes[x][y][z]           = new MeshCubes(vertices,vertices,vertices, tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom);

              cubeVectors[x][y][z]      = new Static3D( STRETCH_SIZE*(x-nc), STRETCH_SIZE*(y-nc), STRETCH_SIZE*(z-nc) );

              mRotationAngle[x][y][z]   = new Dynamic1D();

              mRotationAxis[x][y][z]    = new Static3D(1,0,0);

              mRotationAngle[x][y][z].add(new Static1D(0.0f));

              mRotate[x][y][z] = new MatrixEffectRotate( mRotationAngle[x][y][z], mRotationAxis[x][y][z], center);

              mEffects[x][y][z].apply( new MatrixEffectMove(cubeVectors[x][y][z]) );

              mEffects[x][y][z].apply( mRotate[x][y][z] );

              mEffects[x][y][z].apply(quatEffect);

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

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

    mEffects.apply( new VertexEffectSink(diSink, pLeft , sinkRegion) );

    mEffects.apply( new VertexEffectSink(diSink, pRight, sinkRegion) );

    mEffects.apply( new MatrixEffectScale(mScaleMain));

    bmpHeight = bitmap.getHeight();

    bmpWidth  = bitmap.getWidth();

    if( mTexture==null ) mTexture = new DistortedTexture();

    mTexture.setTexture(bitmap);

    sink.add(new Static1D(1.0f));

    sink.add(new Static1D(0.2f));

    VertexEffectSink sinkEffect = new VertexEffectSink(sink, new Static3D(297, 280, 0), null);

    mEffects.apply(sinkEffect);

    bmpHeight = bitmap.getHeight();

    bmpWidth  = bitmap.getWidth();

    if( mTexture==null ) mTexture = new DistortedTexture();

    mTexture.setTexture(bitmap);

    mScreen.detachAll();

    mScreen.attach(mTexture,mEffects,mMesh);

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static1D;

  private DistortedEffects[] mStarEffects;

  private DistortedNode mBackground;

  private DistortedScreen mScreen;

  private long alphaEffectID, scaleEffectID, moveEffectID;

  private Random mRnd = new Random(0);

    {

    mView = v;

    if( NUM_STARS>0 )

      {

      mStarEffects = new DistortedEffects[NUM_STARS];

      for (int i = 1; i < NUM_STARS; i++)

        mStarEffects[i] = new DistortedEffects(mStarEffects[0], DistortedLibrary.CLONE_VERTEX);

    if( mCrawlBackgroundTexture!=null ) mCrawlBackgroundTexture.markForDeletion();

    mCrawlBackgroundTexture = new DistortedTexture();

    int randomA, randomX, randomY, randomTime;

    float randomS, randomAlpha1, randomAlpha2;

      mStarEffects[i].apply( new FragmentEffectAlpha(di) );

      }

    Dynamic1D di = new Dynamic1D(6000,0.5f);

    di.add(new Static1D(1.0f));

    mGFFAEffects.apply( new MatrixEffectMove(new Static3D(w/5,2*h/3,0)) );

    mGFFAEffects.apply( alpha );

    }

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

    paint.setTypeface(tf);     

    ///// create GFFA ///////////////////

    if( mGFFATexture==null ) mGFFATexture  = new DistortedTexture();

    bitmapGFFA = Bitmap.createBitmap(GFFA_WIDTH,GFFA_HEIGHT,Bitmap.Config.ARGB_8888);

    bitmapGFFA.eraseColor(0x00000000);

    mGFFATexture.setTexture(bitmapGFFA);

    ///// create Logo ///////////////////

    if( mLogoTexture==null ) mLogoTexture  = new DistortedTexture();

    mLogoTexture.setTexture(bitmapLogo);

    ///// create CRAWL //////////////////

    if( mCrawlTexture==null ) mCrawlTexture = new DistortedTexture();

    bitmapText = Bitmap.createBitmap(CRAWL_WIDTH,CRAWL_HEIGHT,Bitmap.Config.ARGB_8888);

    bitmapText.eraseColor(0x00000000);

    mCrawlTexture.setTexture(bitmapText);

    ///// create Stars ///////////////////

    if( mStarTexture==null ) mStarTexture = new DistortedTexture();

    mStarTexture.setTexture(bitmapStar);

    }

      int screenW=mScreen.getWidth();

      int screenH=mScreen.getHeight();

      int initSize= (int)(3.0f*screenW/logoW);

      int finaSize= (int)(0.1f*screenW/logoW);

      mLogoEffects.apply( scale );

      mLogoEffects.apply( new MatrixEffectMove(new Static3D(screenW/2,screenH/2,0)) );

      }

    else if( effectID == scaleEffectID )

      {

      mScreen.detach(mLogoEffects);

      mLogoTexture.markForDeletion();

      mCrawlBackgroundEffects.apply( new MatrixEffectRotate(new Static1D(CRAWL_ANGLE), new Static3D(1,0,0), new Static3D(screenW/2,0,0)) );

      mCrawlEffects.apply( new MatrixEffectScale(new Static3D(scale,scale,scale)) );

      mCrawlEffects.apply( move );

      mBackground.glDisable(GLES31.GL_DEPTH_TEST);