Distorted Android

    private static final int VECTX = 0;  //

    private static final int VECTY = 1;  // don't change this

    private static final int VECTZ = 2;  //

    private Random mRnd = new Random(0);

    void attachToScreen(DistortedScreen screen)

      {

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            {

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mNodes[x][y][z] = new DistortedNode(mTexture,mEffects[x][y][z],mCubes[x][y][z]);

              screen.attach(mNodes[x][y][z]);

              }

            }

      }

// all DistortedTextures, DistortedNodes, DistortedFramebuffers, DistortedScreens and all types of

// Meshes HAVE TO be markedForDeletion when they are no longer needed- otherwise we have a major

// memory leak.

    void releaseResources()

      {

      mTexture.markForDeletion();

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            {

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mCubes[x][y][z].markForDeletion();

              mNodes[x][y][z].markForDeletion();

              }

            }

      }

    void addRotation(EffectListener listener)

      {

      mRnd.setSeed(System.currentTimeMillis());

      int vector = mRnd.nextInt(3);

      int rotRow = mRnd.nextInt(mSize);

      boolean first = true;

      Static3D axis = VectX;

      switch(vector)

        {

        case VECTX: axis = VectX; break;

        case VECTY: axis = VectY; break;

        case VECTZ: axis = VectZ; break;

        }

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              if( belongsToRotation(x,y,z,vector,rotRow) )

                {

                mRotationAxis[x][y][z].set(axis);

                mRotationAngle[x][y][z].makeRunNowFor(ROTATION_MILLISEC);

                mRotationAngle[x][y][z].setPoint(1,90.0f);

                if( first )

                  {

                  first = false;

                  mEffects[x][y][z].registerForMessages(listener);

                  }

                }

              }

      }

// Initial rotation of the cube. Something semi-random that looks good.

   private Static4D initializeQuat()

     return new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);

    private boolean belongsToRotation(int x, int y, int z, int vector, int row)

      {

      switch(vector)

        {

        case VECTX: return x==row;

        case VECTY: return y==row;

        case VECTZ: return z==row;

        }

      return false;

      }

    private float getSinkStrength()

      {

      switch(mSize)

        {

        case 1 : return 1.1f;

        case 2 : return 1.5f;

        case 3 : return 1.8f;

        case 4 : return 2.0f;

        default: return 3.0f - 4.0f/mSize;

        }

      }

    void createTexture()

      {

      Bitmap bitmap;

      final int S = 128;

      final int W = 3*S;

      final int H = 2*S;

      final int R = S/10;

      final int M = S/20;

      Paint paint = new Paint();

      bitmap = Bitmap.createBitmap(W,H, Bitmap.Config.ARGB_8888);

      Canvas canvas = new Canvas(bitmap);

      paint.setAntiAlias(true);

      paint.setTextAlign(Paint.Align.CENTER);

      paint.setStyle(Paint.Style.FILL);

      // 3x2 bitmap = 6 squares:

      //

      // RED     GREEN   BLUE

      // YELLOW  WHITE   BROWN

      paint.setColor(0xff000000);                                  // BLACK BACKGROUND

      canvas.drawRect(0, 0, W, H, paint);                          //

      paint.setColor(0xffff0000);                                  // RED

      canvas.drawRoundRect(    M,   M,   S-M,   S-M, R, R, paint); //

      paint.setColor(0xff00ff00);                                  // GREEN

      canvas.drawRoundRect(  S+M,   M, 2*S-M,   S-M, R, R, paint); //

      paint.setColor(0xff0000ff);                                  // BLUE

      canvas.drawRoundRect(2*S+M,   M, 3*S-M,   S-M, R, R, paint); //

      paint.setColor(0xffffff00);                                  // YELLOW

      canvas.drawRoundRect(    M, S+M,   S-M, 2*S-M, R, R, paint); //

      paint.setColor(0xffffffff);                                  // WHITE

      canvas.drawRoundRect(  S+M, S+M, 2*S-M, 2*S-M, R, R, paint); //

      paint.setColor(0xffb5651d);                                  // BROWN

      canvas.drawRoundRect(2*S+M, S+M, 3*S-M, 2*S-M, R, R, paint); //

      mTexture.setTexture(bitmap);

      }

    float getTextureSize()

      {

      return TEXTURE_SIZE;

      }

    int getSize()

      {

      return mSize;

      }

import org.distorted.library.type.Static4D;

// EffectListener. The library sends a message to us when it's time to call 'removeRotation'

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

      {

      float cameraDistance = CAMERA_DISTANCE*(width>height ? width:height);

      float fovInDegrees   = computeFOV(cameraDistance,height);

      mScreen.setProjection( fovInDegrees, 0.1f);

      mScreen.resize(width, height);

      recomputeScaleFactor(width,height);

      mScreenHeight = height;

      mScreenWidth  = width;

      }

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      createNextCube();

      VertexEffectSink.enable();

      try

        {

        Distorted.onCreate(mView.getContext());

        }

      catch(Exception ex)

        {

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

        }

      }