Magic Cube

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.magic.RubikSurfaceView;

    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.

      mRotAxis = VECTX;

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

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

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

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

     }