Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

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

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

//                                                                                               //

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

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.mesh.MeshCubes;

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 static org.distorted.object.RubikObjectList.VECTY;

import static org.distorted.object.RubikObjectList.VECTZ;

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

    private DistortedEffects[][][] mEffects;

    private Static4D[][][] mQuatScramble;

    private Static3D[][][] mRotationAxis;

    private Dynamic1D[][][] mRotationAngle;

    private Static3D[][][] mCurrentPosition;

// 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[] LEGAL = { 0.0f , 0.5f , -0.5f , 1.0f , -1.0f , SQ2 , -SQ2 };

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

      float y = quat.get1();

      float z = quat.get2();

      float w = quat.get3();

        {

        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 )

            x = -x;

            }

          else if( y==0 )

            {

            if( x<0 )

            }

        }

      {

      switch(vector)

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

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

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

      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 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].set1(roundedY);

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

      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 matrCenter = new Static3D(0,0,0);

      // 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( new MatrixEffectQuaternion(mQuatScramble[x][y][z], matrCenter));

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

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

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

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

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

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

              }

            }

      }

   public void savePreferences(SharedPreferences.Editor editor)

     {

     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 )

              {

              qx = mQuatScramble[x][y][z].get0();

              qy = mQuatScramble[x][y][z].get1();

              qz = mQuatScramble[x][y][z].get2();

              qw = mQuatScramble[x][y][z].get3();

              editor.putFloat("qx_"+x+"_"+y+"_"+z, qx);

              editor.putFloat("qy_"+x+"_"+y+"_"+z, qy);

              editor.putFloat("qz_"+x+"_"+y+"_"+z, qz);

              editor.putFloat("qw_"+x+"_"+y+"_"+z, qw);

              }

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

   public void restorePreferences(SharedPreferences preferences)

     {

     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 )

              {

              qx = preferences.getFloat("qx_"+x+"_"+y+"_"+z, 0.0f);

              qy = preferences.getFloat("qy_"+x+"_"+y+"_"+z, 0.0f);

              qz = preferences.getFloat("qz_"+x+"_"+y+"_"+z, 0.0f);

              qw = preferences.getFloat("qw_"+x+"_"+y+"_"+z, 1.0f);

              mQuatScramble[x][y][z].set(qx,qy,qz,qw);

              modifyCurrentPosition(x, y, z, mQuatScramble[x][y][z]);

              }

     {

     boolean first = true;

     long effectID=0;

       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;

     }

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

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

// memory leak.

     {

     mTexture.markForDeletion();

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

             }

           }

     }

     {

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

     }

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

     {

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

             }

           }

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

     {

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

             }

           }

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

     {

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

             }

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

     {

     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;

     }

     {

     Static3D axis = VectX;

       {

       case VECTX: axis = VectX; break;

       case VECTY: axis = VectY; break;

       case VECTZ: axis = VectZ; break;

       }

     mRotRow  = row;

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

               }

             }

     }

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

      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;

      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;

      }

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

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