Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.object;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshCubes;

import org.distorted.library.mesh.MeshFlat;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.magic.RubikSurfaceView;

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

public class RubikCube extends DistortedNode

{

            static final float CUBE_SCREEN_RATIO = 0.5f;

    private static final int POST_ROTATION_MILLISEC = 500;

    private static final int TEXTURE_SIZE = 100;

    private static final Static3D VectX = new Static3D(1,0,0);

    private static final Static3D VectY = new Static3D(0,1,0);

    private static final Static3D VectZ = new Static3D(0,0,1);

    public static final int VECTX = 0;  //

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

    public static final int VECTZ = 2;  //

    private DistortedNode[][][] mNodes;

    private MeshCubes[][][] mCubes;

    private DistortedEffects[][][] mEffects;

    private Static4D[][][] mQuatScramble;

    private Static3D[][][] mRotationAxis;

    private Dynamic1D[][][] mRotationAngle;

    private Static3D[][][] mCurrentPosition;

    private MatrixEffectRotate[][][] mRotateEffect;

    private Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

    private Static3D mMove, mScale, mNodeMove, mNodeScale;

    private Static4D mQuatAccumulated;

    private DistortedTexture mTexture;

    private int mRotAxis, mRotRow;

    private int mSize;

    private DistortedTexture mNodeTexture;

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

    private int computeNearestAngle(float angle)

      {

      final int NEAREST = 90;

      int tmp = (int)((angle+NEAREST/2)/NEAREST);

      if( angle< -(NEAREST*0.5) ) tmp-=1;

      return NEAREST*tmp;

      }

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

// All legal rotation quats must have all four of their components equal to either

// 0, 1, -1, 0.5, -0.5 or +-sqrt(2)/2.

//

// Because of quatMultiplication, errors can accumulate - so to avoid this, we

// correct the value of the 'scramble' quat to what it should be.

//

// We also have to remember that the group of unit quaternions is a double-cover of rotations

// in 3D ( q represents the same rotation as -q ) - so invert if needed.

    private static final float SQ2 = 0.5f*((float)Math.sqrt(2));

    private static final float[] LEGAL = { 0.0f , 0.5f , -0.5f , 1.0f , -1.0f , SQ2 , -SQ2 };

    private void normalizeScrambleQuat(int i, int j, int k)

      {

      Static4D quat = mQuatScramble[i][j][k];

      float x = quat.get0();

      float y = quat.get1();

      float z = quat.get2();

      float w = quat.get3();

      float diff;

      for(float legal: LEGAL)

        {

        diff = x-legal;

        if( diff*diff<0.01f ) x = legal;

        diff = y-legal;

        if( diff*diff<0.01f ) y = legal;

        diff = z-legal;

        if( diff*diff<0.01f ) z = legal;

        diff = w-legal;

        if( diff*diff<0.01f ) w = legal;

        }

      if( w<0 )

        {

        w = -w;

        z = -z;

        y = -y;

        x = -x;

        }

      else if( w==0 )

        {

        if( z<0 )

          {

          z = -z;

          y = -y;

          x = -x;

          }

        else if( z==0 )

          {

          if( y<0 )

            {

            y = -y;

            x = -x;

            }

          else if( y==0 )

            {

            if( x<0 )

              {

              x = -x;

              }

            }

          }

        }

      mQuatScramble[i][j][k].set(x,y,z,w);

      }

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

    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;

        }

      }

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

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

      {

      switch(vector)

        {

        case VECTX: return mCurrentPosition[x][y][z].get0()==row;

        case VECTY: return mCurrentPosition[x][y][z].get1()==row;

        case VECTZ: return mCurrentPosition[x][y][z].get2()==row;

        }

      return false;

      }

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

    private void modifyCurrentPosition(int x, int y, int z, Static4D quat)

      {

      Static3D current = mCurrentPosition[x][y][z];

      float diff = 0.5f*(mSize-1);

      float cubitCenterX = current.get0() - diff;

      float cubitCenterY = current.get1() - diff;

      float cubitCenterZ = current.get2() - diff;

      Static4D cubitCenter =  new Static4D(cubitCenterX, cubitCenterY, cubitCenterZ, 0);

      Static4D rotatedCenter = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat);

      float rotatedX = rotatedCenter.get0() + diff;

      float rotatedY = rotatedCenter.get1() + diff;

      float rotatedZ = rotatedCenter.get2() + diff;

      int roundedX = (int)(rotatedX+0.1f);

      int roundedY = (int)(rotatedY+0.1f);

      int roundedZ = (int)(rotatedZ+0.1f);

      mCurrentPosition[x][y][z].set0(roundedX);

      mCurrentPosition[x][y][z].set1(roundedY);

      mCurrentPosition[x][y][z].set2(roundedZ);

      }

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

// PUBLIC API

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

    public RubikCube(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshFlat mesh, DistortedEffects effects)

      {

      super(texture,effects,mesh);

      mNodeTexture = texture;

      mSize = size;

      mRotationAngleStatic = new Static1D(0);

      mRotationAngleMiddle = new Static1D(0);

      mRotationAngleFinal  = new Static1D(0);

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

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

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

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

      mQuatAccumulated = quatAcc;

      mRotAxis = VECTX;

      mTexture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);

      mNodes          = new DistortedNode[mSize][mSize][mSize];

      mCubes          = new MeshCubes[mSize][mSize][mSize];

      mEffects        = new DistortedEffects[mSize][mSize][mSize];

      mQuatScramble   = new Static4D[mSize][mSize][mSize];

      mRotationAxis   = new Static3D[mSize][mSize][mSize];

      mRotationAngle  = new Dynamic1D[mSize][mSize][mSize];

      mCurrentPosition= new Static3D[mSize][mSize][mSize];

      mRotateEffect   = new MatrixEffectRotate[mSize][mSize][mSize];

      Static3D[][][] cubeVectors = new Static3D[mSize][mSize][mSize];

      Static3D sinkCenter = new Static3D(TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f);

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

      Static4D region = new Static4D(0,0,0, TEXTURE_SIZE*0.72f);

      VertexEffectSink        sinkEffect = new VertexEffectSink( new Static1D(getSinkStrength()), sinkCenter, region );

      MatrixEffectMove        moveEffect = new MatrixEffectMove(mMove);

      MatrixEffectScale      scaleEffect = new MatrixEffectScale(mScale);

      MatrixEffectQuaternion quatCEffect = new MatrixEffectQuaternion(quatCur, matrCenter);

      MatrixEffectQuaternion quatAEffect = new MatrixEffectQuaternion(quatAcc, matrCenter);

      MatrixEffectMove       nodeMoveEffect  = new MatrixEffectMove(mNodeMove);

      MatrixEffectScale      nodeScaleEffect = new MatrixEffectScale(mNodeScale);

      effects.apply(nodeScaleEffect);

      effects.apply(nodeMoveEffect);

      // 3x2 bitmap = 6 squares:

      //

      // RED     GREEN   BLUE

      // YELLOW  WHITE   BROWN

      final float ze = 0.0f;

      final float ot = 1.0f/3.0f;

      final float tt = 2.0f/3.0f;

      final float oh = 1.0f/2.0f;

      final float of = 1.0f/40.0f;

      final Static4D mapFront = new Static4D(ze,oh, ze+ot,oh+oh);

      final Static4D mapBack  = new Static4D(tt,ze, tt+ot,ze+oh);

      final Static4D mapLeft  = new Static4D(ot,ze, ot+ot,ze+oh);

      final Static4D mapRight = new Static4D(ze,ze, ze+ot,ze+oh);

      final Static4D mapTop   = new Static4D(tt,oh, tt+ot,oh+oh);

      final Static4D mapBottom= new Static4D(ot,oh, ot+ot,oh+oh);

      final Static4D mapBlack = new Static4D(ze,ze, ze+of,ze+of);

      Static4D tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom;

      float nc = 0.5f*mSize;

      int vertices = (int)(24.0f/mSize + 2.0f);

      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 ) // only the external walls

              {

              tmpLeft  = (x==       0 ? mapLeft  :mapBlack);

              tmpRight = (x== mSize-1 ? mapRight :mapBlack);

              tmpFront = (z== mSize-1 ? mapFront :mapBlack);

              tmpBack  = (z==       0 ? mapBack  :mapBlack);

              tmpTop   = (y== mSize-1 ? mapTop   :mapBlack);

              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( TEXTURE_SIZE*(x-nc), TEXTURE_SIZE*(y-nc), TEXTURE_SIZE*(z-nc) );

              mQuatScramble[x][y][z]    = new Static4D(0,0,0,1);

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

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

              mCurrentPosition[x][y][z] = new Static3D(x,y,z);

              mRotateEffect[x][y][z]    = new MatrixEffectRotate(mRotationAngle[x][y][z], mRotationAxis[x][y][z], matrCenter);

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

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

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

              mEffects[x][y][z].apply( new MatrixEffectQuaternion(mQuatScramble[x][y][z], matrCenter));

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

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

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

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

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

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

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

              }

            }

      }

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

    public void addNewRotation(int vector, int row )

      {

      Static3D axis = VectX;

      switch(vector)

        {

        case VECTX: axis = VectX; break;

        case VECTY: axis = VectY; break;

        case VECTZ: axis = VectZ; break;

        }

      mRotAxis = vector;

      mRotRow  = row;

      mRotationAngleStatic.set0(0.0f);

      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,mRotRow) )

                {

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

                mRotationAngle[x][y][z].add(mRotationAngleStatic);

                }

              }

      }

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

    public void continueRotation(float angleInDegrees)

      {

      mRotationAngleStatic.set0(angleInDegrees);

      }

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

    public Static4D getRotationQuat()

      {

      return mQuatAccumulated;

      }

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

    public long finishRotationNow(EffectListener listener)

      {

      boolean first = true;

      long effectID=0;

      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,mRotAxis,mRotRow) )

                {

                if( first )

                  {

                  first = false;

                  mRotateEffect[x][y][z].notifyWhenFinished(listener);

                  effectID = mRotateEffect[x][y][z].getID();

                  int pointNum = mRotationAngle[x][y][z].getNumPoints();

                  if( pointNum>=1 )

                    {

                    float startingAngle = mRotationAngle[x][y][z].getPoint(pointNum-1).get0();

                    int nearestAngleInDegrees = computeNearestAngle(startingAngle);

                    mRotationAngleStatic.set0(startingAngle);

                    mRotationAngleFinal.set0(nearestAngleInDegrees);

                    mRotationAngleMiddle.set0( nearestAngleInDegrees + (nearestAngleInDegrees-startingAngle)*0.2f );

                    }

                  else

                    {

                    android.util.Log.e("cube", "ERROR finishing rotation!");

                    return 0;

                    }

                  }

                mRotationAngle[x][y][z].setDuration(POST_ROTATION_MILLISEC);

                mRotationAngle[x][y][z].resetToBeginning();

                mRotationAngle[x][y][z].removeAll();

                mRotationAngle[x][y][z].add(mRotationAngleStatic);

                mRotationAngle[x][y][z].add(mRotationAngleMiddle);

                mRotationAngle[x][y][z].add(mRotationAngleFinal);

                }

              }

      return effectID;

      }

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

// 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.

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

              }

            }

      }

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

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

      }

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

    public void recomputeScaleFactor(int screenWidth, int screenHeight)

      {

      int texW = mNodeTexture.getWidth();

      int texH = mNodeTexture.getHeight();

      if( (float)texH/texW > (float)screenHeight/screenWidth )

        {

        int w = (screenHeight*texW)/texH;

        float factor = (float)screenHeight/texH;

        mNodeMove.set((screenWidth-w)*0.5f ,0, 0);

        mNodeScale.set(factor,factor,factor);

        }

      else

        {

        int h = (screenWidth*texH)/texW;

        float factor = (float)screenWidth/texW;

        mNodeMove.set(0,(screenHeight-h)*0.5f,0);

        mNodeScale.set(factor,factor,factor);

        }

      float scaleFactor = (CUBE_SCREEN_RATIO*texW/(TEXTURE_SIZE*mSize));

      mMove.set( texW*0.5f , texH*0.5f , 0.0f );

      mScale.set(scaleFactor,scaleFactor,scaleFactor);

      }

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

    public void apply(Effect effect, int position)

      {

      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 )

              {

              mEffects[x][y][z].apply(effect, position);

              }

            }

      }

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

    public void remove(long effectID)

      {

      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 )

              {

              mEffects[x][y][z].abortById(effectID);

              }

            }

      }

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

    public void solve()

      {

      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 )

              {

              mQuatScramble[x][y][z].set(0,0,0,1);

              mCurrentPosition[x][y][z].set(x,y,z);

              }

      }

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

    public boolean isSolved()

      {

      Static4D q = mQuatScramble[0][0][0];

      float x = q.get0();

      float y = q.get1();

      float z = q.get2();

      float w = q.get3();

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

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

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

            {

            if( i==0 || i==mSize-1 || j==0 || j==mSize-1 || k==0 || k==mSize-1 )

              {

              q = mQuatScramble[i][j][k];

              if( q.get0()!=x || q.get1()!=y || q.get2()!=z || q.get3()!=w )

                {

                return false;

                }

              }

            }

      return true;

      }

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

    public int getSize()

      {

      return mSize;

      }

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

    public long addNewRotation(int vector, int row, int angle, long durationMillis, EffectListener listener )

      {

      Static3D axis = VectX;

      long effectID=0;

      boolean first = true;

      switch(vector)

        {

        case VECTX: axis = VectX; break;

        case VECTY: axis = VectY; break;

        case VECTZ: axis = VectZ; break;

        }

      mRotAxis = vector;

      mRotRow  = row;

      mRotationAngleStatic.set0(0.0f);

      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,mRotRow) )

                {

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

                mRotationAngle[x][y][z].setDuration(durationMillis);

                mRotationAngle[x][y][z].resetToBeginning();

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

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

                if( first )

                  {

                  first = false;

                  effectID = mRotateEffect[x][y][z].getID();

                  mRotateEffect[x][y][z].notifyWhenFinished(listener);

                  }

                }

              }

      return effectID;

      }

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

    public void removeRotationNow()

      {

      float qx=0,qy=0,qz=0;

      boolean first = true;

      Static4D quat = null;

      switch(mRotAxis)

        {

        case VECTX: qx=1; break;

        case VECTY: qy=1; break;

        case VECTZ: qz=1; 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,mRotAxis,mRotRow) )

                {

                if( first )

                  {

                  first = false;

                  int pointNum = mRotationAngle[x][y][z].getNumPoints();

                  if( pointNum>=1 )

                    {

                    float startingAngle = mRotationAngle[x][y][z].getPoint(pointNum-1).get0();

                    int nearestAngleInDegrees = computeNearestAngle(startingAngle);

                    double nearestAngleInRadians = nearestAngleInDegrees*Math.PI/180;

                    float sinA =-(float)Math.sin(nearestAngleInRadians*0.5);

                    float cosA = (float)Math.cos(nearestAngleInRadians*0.5);

                    quat = new Static4D(qx*sinA, qy*sinA, qz*sinA, cosA);

                    }

                  else

                    {

                    android.util.Log.e("cube", "ERROR removing rotation!");

                    return;

                    }

                  }

                mRotationAngle[x][y][z].removeAll();

                mQuatScramble[x][y][z].set(RubikSurfaceView.quatMultiply(quat,mQuatScramble[x][y][z]));

                normalizeScrambleQuat(x,y,z);

                modifyCurrentPosition(x,y,z,quat);

                }

              }

      mRotationAngleStatic.set0(0);

      }

}