Distorted Android

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffectChroma;

import org.distorted.library.effect.FragmentEffectContrast;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectDistort;

import org.distorted.library.effect.VertexEffectPinch;

   private DistortedScreen mScreen;

   private MeshFlat mMesh;

   private AroundTheWorldEffectsManager mManager;

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

   AroundTheWorldRenderer(GLSurfaceView view)

      {

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

      mView = view;

      mManager = new AroundTheWorldEffectsManager();

      mEffects = new DistortedEffects();

      mEffects.apply(new MatrixEffectScale(mScale));

      mManager.apply(mEffects);

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

      {

      mScreen.resize(width,height);

      }

        catch(IOException e) { }

        }

      mTexture.setTexture(bitmap);

      mScreen.detachAll();

      mScreen.attach(mTexture, mEffects, mMesh);

    private MeshFlat mMesh;

    private Static1D mRadiusSta;

    private int mObjHeight, mObjWidth;

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

      Dynamic1D radiusDyn = new Dynamic1D();

      radiusDyn.add(mRadiusSta);

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

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

      mBufferEffects = new DistortedEffects();

      mBufferEffects.apply(new MatrixEffectScale(mBufferScale));

      mEffects = new DistortedEffects();

      mEffects.apply( new PostprocessEffectBlur(radiusDyn) );

      mEffects.apply(new MatrixEffectScale(mScale));

      }

     float qw1 = (float)width /SIZE;

     float qh1 = (float)height/SIZE;

     float factor1 = 0.8f* (qw1<qh1 ? qw1:qh1);

     mBufferScale.set( factor1,factor1,factor1 );

     float qw2 = (float)SIZE/mObjWidth;

     float qh2 = (float)SIZE/mObjHeight;

     float factor2 = 0.9f* (qw2<qh2 ? qw2:qh2);

     mScale.set( factor2,factor2,factor2 );

     mScreen.resize(width, height);

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.FragmentEffectChroma;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectSwirl;

    private MeshFlat mMesh;

    private DistortedScreen mScreen;

    private int mObjHeight, mObjWidth;

    private Static3D mSwirl1, mSwirl2, mDeform1, mDeform2;

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

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

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

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

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

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

      mEffects = new DistortedEffects();

      mEffects.apply(new MatrixEffectScale(mScale));

      // Try adding 2 Vertex Effects to the Bitmap.

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

      mScale.set(factor,factor,factor);

      mScreen.resize(width,height);

   private Static4D mRegion;

   private int scrHeight, scrWidth;

   private float mRadius;

   private EffectName mMode = EffectName.DISTORT;

     mRegion.set4(mRadius*scrWidth);

     Canvas stretchCanvas;

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

     stretchCanvas = new Canvas(stretchBitmap);

     Paint paint = new Paint();

     paint.setColor(0xff008800);

     paint.setStyle(Style.FILL);

     paint.setColor(0xffffffff);

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

       {

       }

     stretchTexture.setTexture(stretchBitmap);

     mScreen.detachAll();

   void down(int x, int y)

     {

     switch(mMode)

       {

       case DISTORT: vDistort[0].set(0,0,0);

                     stretchEffects.apply(mMovingDistort);

                     mLastEffect = mMovingDistort.getID();

                     break;

       case DEFORM : vDeform[0].set(0,0,0);

                     stretchEffects.apply(mMovingDeform);

                     mLastEffect = mMovingDeform.getID();

                     break;

       case SHEAR  : vShear[0].set(0,0,0);

                     stretchEffects.apply(mMovingShear);

                     mLastEffect = mMovingShear.getID();

                     break;

       }

     }

                     break;

       case DEFORM:  vDeform[0].set(x,-y,0);

                     break;

                     break;

       }

     }

class DifferentBitmapsRenderer implements GLSurfaceView.Renderer 

{

   private GLSurfaceView mView;

   private DistortedEffects[] mEffects;

   private DistortedTexture[] mTexture;

   private MeshFlat mMesh;

   private DistortedScreen mScreen;

   private Static3D mScale;

   private Static3D[] mMove;

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

      }

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

   public void onDrawFrame(GL10 glUnused)

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

     {

     mScreen.resize(width, height);

     }

   public void onSurfaceCreated(GL10 glUnused, EGLConfig config)

     {

     if( mTexture==null )

       {

         mTexture[i] = new DistortedTexture(bmpWidth,bmpHeight);

       }

     if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);

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

       }

     }

}

   private DistortedTexture mTexture;

   private MeshFlat mMesh;

   private DistortedScreen mScreen;

   private Static3D mScale;

   private Static3D[] mMove;

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

     {

     mScreen.resize(width, height);

     }

       catch(IOException e) { }

       }

     if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);

     if( mTexture==null ) mTexture  = new DistortedTexture(bmpWidth,bmpHeight);

    private static final int   RADIUS_F= SIZE/15;

    private static final int   LEVEL   =      40;

    private static final float FOV     =   30.0f;

    private static final int   MAX_EFF =      20;

    private static final float SCALE   =   1.10f;

    private MeshBase mMesh;

    private DistortedScreen mScreen;

    private int mObjWidth, mObjHeight, mObjDepth;

    private int mScrWidth, mScrHeight;

    private float mLevel;

      mRegionV    = new Static4D(0,0,0,RADIUS_V);

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

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

      mPinch      = new Static2D(0.5f,0.0f);

      mSwirl      = new Static1D(45.0f);

      Dynamic3D scale = new Dynamic3D(0,0.5f);

      scale.add(mScaleFactor);

      mEffects = new DistortedEffects();

      mEffects.apply( new MatrixEffectMove(mMove) );

      mEffects.apply( new MatrixEffectScale(scale));

      mScreen = new DistortedScreen();

      mScreen.setProjection(FOV, NEAR);

      adjustFactor();

      mScreen.resize(width, height);

      }

    void setLevel(int level)

      {

      // MAP: 0--> SCALE/N   50-->SCALE   100->SCALE*N

      mLevel = SCALE* (1.0f+  (level>=50 ? N-1 : (N-1)/N) * (level-50)/50.0f);

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

      mScaleFactor.set(factor,factor,factor);

      }

      {

      tr = (TableRow)mLay.getChildAt(row);

        {

        }

      }

    }

    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;

      mObjWidth = mObjectTexture.getWidth();

      mObjHeight= mObjectTexture.getHeight();

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

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

      resetMatrixEffects();

      backgroundEffects.apply(new MatrixEffectMove(mMoveBackground) );

      backgroundEffects.apply(new MatrixEffectScale(mScaleBackground) );

      }

      {

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

      DistortedEffects objectEffects= act.getEffects();

      MatrixEffectQuaternion quat1obj = new MatrixEffectQuaternion(mQuat1,  rotateObj);

      MatrixEffectQuaternion quat2obj = new MatrixEffectQuaternion(mQuat2,  rotateObj);

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

      mScaleCenter.set(factorCen,factorCen,factorCen);

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

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

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

      mScaleBackground.set( 2*factorBackX, 2*factorBackY, 1.0f );

      mScreen.resize(width, height);

import org.distorted.examples.R;

import org.distorted.library.effect.EffectQuality;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.PostprocessEffectGlow;

import org.distorted.library.main.Distorted;

   private DistortedScreen mScreen;

   private PostprocessEffectGlow mGlow;

   private int mRootW, mRootH;

   private Static1D mRadius;

   private Static4D mColor;

      mRootW = LEAF_SIZE;

      mRootH = LEAF_SIZE;

      mLeaf  = new DistortedTexture(mRootW,mRootH);

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

      mRadius= new Static1D(25);

      mColor = new Static4D(1.0f,0.0f,0.0f,0.5f); // half-transparent red

      mGlow  = new PostprocessEffectGlow(mRadius,mColor);

      DistortedEffects effects = new DistortedEffects();

      effects.apply(new MatrixEffectScale(mScale));

      effects.apply(mGlow);

     float qw = (float)width /mRootW;

     float qh = (float)height/mRootH;

     float factor = 0.8f* (qw<qh ? qw:qh);

     mScale.set( factor,factor,factor );

     mScreen.resize(width, height);

     }

import javax.microedition.khronos.opengles.GL10;

import org.distorted.library.effect.FragmentEffectAlpha;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedEffects;

    private DistortedEffects mEffects;

    private MeshBase mMesh;

    private DistortedScreen mScreen;

    private Static1D mAlpha;

    Static4D mQuat1, mQuat2;

      mAlpha = new Static1D(1.0f);

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

      InflateActivity2 act = (InflateActivity2)v.getContext();

      mObjWidth = mTexture.getWidth();

      mObjHeight= mTexture.getHeight();

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

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

      quatInt2.add(mQuat2);

      mEffects = new DistortedEffects();

      mEffects.apply( new MatrixEffectScale(mScale));

      mEffects.apply( new FragmentEffectAlpha(mAlpha));

      mScreen = new DistortedScreen();

      mScreenMin = width<height ? width:height;

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

      mScale.set(factor,factor,factor);

      mScreen.resize(width, height);

      }

      {

      mX = pos;

      }

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

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

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

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

        float headScale = HEAD_SCALE *mScreenH/ mHeadH;

        mScaleHead.set(headScale,headScale,headScale);

        setPosition(mX);

        mOffScreen1.attach( mTextureMirror, mEffectsMirror    , mQuad );

   private PostprocessEffectGlow[] mGlow = new PostprocessEffectGlow[NUM_LEAVES];

   private int mRootW, mRootH;

   private int mGlowing;

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

      DistortedNode root = new DistortedNode(surface, new DistortedEffects(), mesh);

      Static1D chromaLevel= new Static1D(0.5f);

      Static3D axis       = new Static3D(0,0,1);

      MatrixEffectMove leafMove = new MatrixEffectMove(moveVector);

        root.attach(node);

        }

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

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

      rot.add(new Static1D(360));

      DistortedEffects effects = root.getEffects();

      effects.apply(new MatrixEffectScale(mScale));

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

     float qw = (float)width /mRootW;

     float qh = (float)height/mRootH;

     float factor = 0.9f* (qw<qh ? qw:qh);

     mScale.set( factor,factor,factor );

     mScreen.resize(width, height);

     }

    private PostprocessEffectBlur mBlur;

    private int mDistance;

    private boolean[] mBlurStatus;

    Static4D mQuat1, mQuat2;

    int mScreenMin;

      mBlurStatus[0] = true;

      effects[0].apply(mBlur);

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

      MatrixEffectScale scaleEffect = new MatrixEffectScale(mScale);

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

        {

        effects[i].apply(scaleEffect);

        effects[i].apply(quatEffect1);

        effects[i].apply(quatEffect2);

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

      {

    	mScale.set(factor,factor,factor);

      computeMoveVectors();

      mScreen.resize(width, height);

      }

    private void computeMoveVectors()

      {

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

        {

        {

        android.util.Log.e("renderer", "Error, number: "+number+" checked: "+checked );

        }

      }

}

import org.distorted.examples.R;

import org.distorted.library.effect.FragmentEffectChroma;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectSink;

   private DistortedNode mRoot;

   private MeshFlat mMeshFlat;

   private MeshCubes mMeshCubes;

   private boolean mDepth;

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

      mView   = v;

      mDepth  = true;

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

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

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

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

      mEffects= new DistortedEffects();

      mEffects.apply(new MatrixEffectScale(mScale));

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

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

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

      mScreen.resize(width, height);

      }

        catch(IOException e) { }

        }  

      int gridWidth = bitmap2.getWidth();

      int gridHeight= bitmap2.getHeight();

      mScreen.attach(mRoot);

      float factor = lisaWidth/(2.0f*gridWidth);

      MatrixEffectScale scale = new MatrixEffectScale( new Static3D(factor,factor,factor) );

      gridEffects.apply(scale);

      Dynamic1D rotDyn = new Dynamic1D(12000,0.0f);

      rotDyn.add(new Static1D(  0));

      rotDyn.add(new Static1D(360));

      rotDyn.setMode(Dynamic.MODE_JUMP);

      gridEffects.apply(rotate);

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

   private MeshFlat mMesh;

   private int mScreenW, mScreenH;

   private int mPrevRendered, mCurrRendered;

   private DistortedNode[] mCircleNode = new DistortedNode[NUM_CIRCLES];

   private DistortedEffects[] mEffects = new DistortedEffects[NUM_LEAVES];

      mLeaf = new DistortedTexture(LEAF_SIZE,LEAF_SIZE);

      DistortedTexture surface = new DistortedTexture(3*LEAF_SIZE,3*LEAF_SIZE);

      mMesh = new MeshFlat(1,1);

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

      DistortedEffects effects = new DistortedEffects();

      effects.apply(new MatrixEffectScale(mScale));

      mScreenW = 9*LEAF_SIZE;

      mScreenH = 9*LEAF_SIZE;

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

      rot.setMode(Dynamic1D.MODE_JUMP);

      rot.add(new Static1D(360));

      int[] colors    = new int[] {0,0,1,  0,0,0,  1,0,0,  1,1,0,  0,1,0}; // blue, black, red, yellow, green  

      Static3D axis   = new Static3D(0,0,1);

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

        {

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

     {

     mScreen.resize(width, height);

     }

   private DistortedTexture mLeaf;

   private DistortedScreen mScreen;

   private int mScreenW, mScreenH;

   private Static1D mRadius;

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

      mLeaf = new DistortedTexture(LEAF_SIZE,LEAF_SIZE);

      MeshFlat mesh = new MeshFlat(1,1);

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

      DistortedEffects rootEffects  = new DistortedEffects();

      DistortedNode root = new DistortedNode(new DistortedTexture(mScreenW,mScreenH), rootEffects, mesh);

      rootEffects.apply(new MatrixEffectScale(mScale));

      rootEffects.apply(blurEffect);

      rotate.add(new Static1D(  0));

      rotate.add(new Static1D(360));

      Static3D axis   = new Static3D(0,0,1);

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

        {

        outerLeafEffects[j] = new DistortedEffects();

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

        root.attach(mLeaf, outerLeafEffects[j], mesh);

        }

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

      innerEffects.apply(blurEffect);

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

        {

        innerLeafEffects[j] = new DistortedEffects();

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

        innerNode.attach( mLeaf, innerLeafEffects[j], mesh );

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

     {

     mScale.set(factor,factor,factor);

     mScreen.resize(width, height);

     }

import org.distorted.examples.R;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshCubes;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.DynamicQuat;

  private GLSurfaceView mView;

  private DistortedTexture mTexture;

  private DistortedScreen mScreen;

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

    {

    mView    = v;

    mTexture = new DistortedTexture(1,1);

    DistortedEffects effects = new DistortedEffects();

    DynamicQuat rot = new DynamicQuat();

    rot.setDuration(8000);

    rot.setMode(Dynamic.MODE_LOOP);

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

    effects.apply(new MatrixEffectScale(mScale));

    mScreen = new DistortedScreen();

    }

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

    {

    float w = mTexture.getWidth();

    float h = mTexture.getHeight();

    float factor = 0.5f*(width>height ? height/h:width/w);

    mScale.set(factor,factor,factor);

    mScreen.resize(width, height);

    }

    private GLSurfaceView mView;

    private DistortedTexture mTexture;

    private DistortedScreen mScreen;

    private MeshCubes[][][] mCubes;

    private DistortedEffects[][][] mEffects;

      mEffects = new DistortedEffects[CUBE_SIZE][CUBE_SIZE][CUBE_SIZE];

      Static3D[][][] cubeVectors = new Static3D[CUBE_SIZE][CUBE_SIZE][CUBE_SIZE];

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

      MatrixEffectScale      scale = new MatrixEffectScale(mScale);

      // 3x2 bitmap = 6 squares:

      //

            mEffects[x][y][z] = new DistortedEffects();

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

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

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

      float w = mTexture.getWidth();

      float h = mTexture.getHeight();

      float factor = 0.6f*(width>height ? height/h:width/w)/CUBE_SIZE;

      mScale.set(factor,factor,factor);

      mScreen.resize(width, height);

      }

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

    {

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

    int randomA, randomX, randomY, randomTime;

    float randomS, randomAlpha1, randomAlpha2;

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

      {

      randomS = 0.2f+ 0.8f*mRnd.nextFloat();

      randomA = (int)(180*mRnd.nextFloat());

      randomAlpha1 = 0.2f + 0.8f*mRnd.nextFloat();

      mScreen.attach(mStarTexture, mStarEffects[i], mQuad);

      }

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

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

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

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

    mGFFAEffects.apply( new MatrixEffectScale(scale) );

    mGFFAEffects.apply( new FragmentEffectAlpha(di) );

        mGFFATexture.markForDeletion();

        int screenW=mScreen.getWidth();

        int logoW = mLogoTexture.getWidth();

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

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

        di.add(new Static3D(initSize,initSize,1));

        di.add(new Static3D(finaSize,finaSize,1));

        mLogoEffects.apply( new MatrixEffectScale(di) );

        mScreen.attach(mLogoTexture, mLogoEffects,mQuad);

        mLogoEffects.registerForMessages(this);

        }

        int crawlW = mCrawlTexture.getWidth();

        int crawlH = mCrawlTexture.getHeight();

        int screenW= mScreen.getWidth();

        int backH  = mCrawlBackgroundTexture.getHeight();

        final int transpDist = 5;

        Static3D center = new Static3D( screenW/2 , transpDist*backH , 0 );

        mCrawlBackgroundEffects.apply( new FragmentEffectAlpha(new Static1D(1-transpDist*0.6f), center, region, true) );

        Dynamic3D di = new Dynamic3D(70000,0.5f);

        mCrawlEffects.apply( new MatrixEffectMove(di) );

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

        mBackground = mScreen.attach(mCrawlBackgroundTexture, mCrawlBackgroundEffects,mQuad);

        mBackground.attach(mCrawlTexture, mCrawlEffects,mQuad);

        mBackground.glDisable(GLES31.GL_DEPTH_TEST);

    private DistortedScreen mScreen;

    private DistortedTexture mCubeTex, mFloorTex, mFBOTex;

    private DistortedNode mCube1Node, mCube2Node, mFloorNode, mFBONode;

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

      MeshBase cube = new MeshCubes(1,1,1);

      MeshBase quad = new MeshQuad();

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

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

      mCubeTex   = new DistortedTexture(1,1);

      setScreen(true);

      float cw = mCubeTex.getWidth();

      Static3D axisX = new Static3D(1,0,0);

      Static3D axisZ = new Static3D(0,0,1);

      rotDyn.add(new Static1D(  0));

      rotDyn.add(new Static1D(360));

      MatrixEffectScale  scale = new MatrixEffectScale(mScale);

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

      // First move the cube and its reflection to the middle of the floor. Then scale the floor, the cube

      // middle of the screen.

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

      // The cube

      cube1Effects.apply( rotaX );

      cube1Effects.apply( rotaZ );

      cube1Effects.apply( scale );

      cube1Effects.apply( move1 );

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

      // Floor

      floorEffects.apply( rotaX );

      floorEffects.apply( rotaZ );

      floorEffects.apply( scale );

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

      // Reflection

      cube2Effects.apply( rotaX );

      cube2Effects.apply( rotaZ );

      cube2Effects.apply( scale );

      cube2Effects.apply( new MatrixEffectScale(new Static3D(1,1,-1)) );

      cube2Effects.apply( new FragmentEffectBrightness(new Static1D(0.5f)) );

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

      float cw = mCubeTex.getWidth();

      float ch = mCubeTex.getHeight();

      float bw = mFBOTex.getWidth();