Magic Cube

    private static final Static3D matrCenter = new Static3D(0,0,0);

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

    private class Cubit

      private final Static3D mOrigPosition;

      DistortedNode mNode;

      MeshCubes mCube;

      DistortedEffects mEffect;

      Static4D mQuatScramble;

      Static3D mRotationAxis;

      Dynamic1D mRotationAngle;

      Static3D mCurrentPosition;

      MatrixEffectRotate mRotateEffect;

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

      Cubit(MeshCubes mesh,Static3D vector, Static3D position)

        mOrigPosition = new Static3D( position.get0(), position.get1(), position.get2() );

        mCube = mesh;

        mQuatScramble    = new Static4D(0,0,0,1);

        mRotationAngle   = new Dynamic1D();

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

        mCurrentPosition = position;

        mRotateEffect    = new MatrixEffectRotate(mRotationAngle, mRotationAxis, matrCenter);

        mEffect = new DistortedEffects();

        mEffect.apply(mSinkEffect);

        mEffect.apply( new MatrixEffectMove(vector) );

        mEffect.apply( new MatrixEffectQuaternion(mQuatScramble, matrCenter));

        mEffect.apply(mRotateEffect);

        mEffect.apply(mQuatAEffect);

        mEffect.apply(mQuatCEffect);

        mEffect.apply(mScaleEffect);

        mEffect.apply(mMoveEffect);

        mNode = new DistortedNode(mTexture,mEffect,mCube);

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

      void savePreferences(SharedPreferences.Editor editor)

        String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();

        editor.putFloat("qx_"+number, mQuatScramble.get0());

        editor.putFloat("qy_"+number, mQuatScramble.get1());

        editor.putFloat("qz_"+number, mQuatScramble.get2());

        editor.putFloat("qw_"+number, mQuatScramble.get3());

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

      void restorePreferences(SharedPreferences preferences)

        String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();

        float qx = preferences.getFloat("qx_"+number, 0.0f);

        float qy = preferences.getFloat("qy_"+number, 0.0f);

        float qz = preferences.getFloat("qz_"+number, 0.0f);

        float qw = preferences.getFloat("qw_"+number, 1.0f);

        mQuatScramble.set(qx,qy,qz,qw);

        modifyCurrentPosition( mCurrentPosition, mQuatScramble);

        }

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

      long finishRotationNow(EffectListener listener)

        {

        int pointNum = mRotationAngle.getNumPoints();

        if( pointNum>=1 )

          float startingAngle = mRotationAngle.getPoint(pointNum-1).get0();

          int nearestAngleInDegrees = computeNearestAngle(startingAngle);

          mRotationAngleStatic.set0(startingAngle);

          mRotationAngleFinal.set0(nearestAngleInDegrees);

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

          return setUpCallback(listener);

        else

          return 0;

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

      Static4D returnRotationQuat(float qx,float qy,float qz)

        {

        int pointNum = mRotationAngle.getNumPoints();

        if( pointNum>=1 )

          {

          float startingAngle = mRotationAngle.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);

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

          }

        else

          {

          return null;

          }

        }

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

      void removeRotationNow(Static4D quat)

        mRotationAngle.removeAll();

        mQuatScramble.set(RubikSurfaceView.quatMultiply(quat,mQuatScramble));

        normalizeScrambleQuat( mQuatScramble );

        modifyCurrentPosition( mCurrentPosition,quat);

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

      void releaseResources()

        {

        mCube.markForDeletion();

        mNode.markForDeletion();

        }

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

      void solve()

        {

        mQuatScramble.set(0,0,0,1);

        mCurrentPosition.set(mOrigPosition);

        }

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

      void beginNewRotation(Static3D axis)

        {

        mRotationAxis.set(axis);

        mRotationAngle.add(mRotationAngleStatic);

        }

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

      void addNewRotation(Static3D axis, long durationMillis, int angle)

        {

        mRotationAxis.set(axis);

        mRotationAngle.setDuration(durationMillis);

        mRotationAngle.resetToBeginning();

        mRotationAngle.add(new Static1D(0));

        mRotationAngle.add(new Static1D(angle));

        }

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

      long setUpCallback(EffectListener listener)

        {

        mRotateEffect.notifyWhenFinished(listener);

        return mRotateEffect.getID();

        }

    private Cubit[][][] mCubits;

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

    float[] getLegalQuats()

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

      return new float[] { 0.0f , 0.5f , -0.5f , 1.0f , -1.0f , SQ2 , -SQ2 };

      }

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

    private boolean belongsToRotation( Static3D currentPosition, int vector, int row)

      {

      switch(vector)

        {

        case VECTX: return currentPosition.get0()==row;

        case VECTY: return currentPosition.get1()==row;

        case VECTZ: return currentPosition.get2()==row;

        }

      return false;

      mCubits  = new Cubit[mSize][mSize][mSize];

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

                                           new Static3D( TEXTURE_SIZE*(x-nc), TEXTURE_SIZE*(y-nc), TEXTURE_SIZE*(z-nc) ),

                                           new Static3D(x,y,z) );

              attach(mCubits[x][y][z].mNode);

              mCubits[x][y][z].savePreferences(editor);

              mCubits[x][y][z].restorePreferences(preferences);

             if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,mRotAxis,mRotRow) )

                 effectID = mCubits[x][y][z].finishRotationNow(listener);

               resetRotationAngle(mCubits[x][y][z].mRotationAngle);

             mCubits[x][y][z].releaseResources();

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

             mCubits[x][y][z].mEffect.abortById(effectID);

             mCubits[x][y][z].solve();

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

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

             if( belongsToRotation( mCubits[x][y][z].mCurrentPosition,vector,mRotRow) )

               mCubits[x][y][z].beginNewRotation(axis);

              if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,vector,mRotRow) )

                mCubits[x][y][z].addNewRotation(axis,durationMillis,angle);

                  effectID = mCubits[x][y][z].setUpCallback(listener);

              if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,mRotAxis,mRotRow) )

                  quat = mCubits[x][y][z].returnRotationQuat(qx,qy,qz);

                mCubits[x][y][z].removeRotationNow(quat);

import org.distorted.library.type.Dynamic1D;

import org.distorted.magic.RubikSurfaceView;

  private static final int POST_ROTATION_MILLISEC = 500;

  private final float[] LEGAL_QUATS;

    LEGAL_QUATS = getLegalQuats();

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

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

// correct the value of the 'scramble' quat to what it should be - one of the legal quats from the

// list LEGAL_QUATS.

//

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

    void normalizeScrambleQuat(Static4D quat)

      {

      float x = quat.get0();

      float y = quat.get1();

      float z = quat.get2();

      float w = quat.get3();

      float diff;

      for(float legal: LEGAL_QUATS)

        {

        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;

              }

            }

          }

        }

      quat.set(x,y,z,w);

      }

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

  void resetRotationAngle(Dynamic1D rotationAngle)

    {

    rotationAngle.setDuration(POST_ROTATION_MILLISEC);

    rotationAngle.resetToBeginning();

    rotationAngle.removeAll();

    rotationAngle.add(mRotationAngleStatic);

    rotationAngle.add(mRotationAngleMiddle);

    rotationAngle.add(mRotationAngleFinal);

    }

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

  void modifyCurrentPosition(Static3D currentPosition, Static4D quat)

    {

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

    float cubitCenterX = currentPosition.get0() - diff;

    float cubitCenterY = currentPosition.get1() - diff;

    float cubitCenterZ = currentPosition.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);

    currentPosition.set(roundedX, roundedY, roundedZ);

    }

  abstract float[] getLegalQuats();