Magic Cube

import org.distorted.object.RubikCubeMovement;

     RubikCubeMovement movement = new RubikCubeMovement(mNewCube);

     mView.setMovement(movement);

        float ratio = axisL/mScreenMin;

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

    void setMovement(RubikCubeMovement movement)

      {

      mMovement = movement;

      }

      float x = event.getX() - mScreenWidth*0.5f;

      float y = mScreenHeight*0.5f -event.getY();

                                       mLastTouchedFace = mMovement.faceTouched(mQuatAccumulated,mCameraDistance, x, y);

                                         int minimumDist = (mScreenMin*mScreenMin)/(DIRECTION_SENSITIVITY*DIRECTION_SENSITIVITY);

                                         if( (mX-x)*(mX-x) + (mY-y)*(mY-y) > minimumDist )

                                         int minimumDistToStartRotating = (mScreenMin*mScreenMin)/(ROTATION_SENSITIVITY*ROTATION_SENSITIVITY);

                                         if( (mX-x)*(mX-x)+(mY-y)*(mY-y) > minimumDistToStartRotating )

                                           mMovement.addNewRotation(mQuatAccumulated,mLastTouchedFace, x, y);

                                         mMovement.continueRotation(mQuatAccumulated,mLastTouchedFace, x, y, mScreenMin);

    private static final float CUBE_SCREEN_RATIO = 0.5f;

    private float mCubeSizeInScreenSpace;

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

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

                }

              }

      }

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

    void continueRotation(float angleInDegrees)

      {

      mRotationAngleStatic.set1(angleInDegrees);

      }

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

    float returnCubeSizeInScreenSpace()

      {

      return mCubeSizeInScreenSpace;

      }

      mCubeSizeInScreenSpace = CUBE_SCREEN_RATIO*(screenWidth>screenHeight ? screenHeight:screenWidth);

      float scaleFactor = (mCubeSizeInScreenSpace/(TEXTURE_SIZE*mSize)) * (float)texW/(screenWidth>screenHeight ? screenHeight:screenWidth);

    // Moving the finger from the middle of the vertical screen to the right edge will rotate a

    // given face by SWIPING_SENSITIVITY/2 degrees.

    private final static int SWIPING_SENSITIVITY  = 240;

    private RubikCube mCube;

    private float[] mPoint, mCamera, mTouchPointCastOntoFace, mDiff, mTouchPoint; // all in screen space

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

    private boolean faceIsVisible(int face, float cubeHalfSize)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceZaxis(face);

      return sign*mCamera[zAxis] > cubeHalfSize;

      }

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

    private void convertTouchPointToScreenSpace(Static4D accumulated, float x, float y)

      {

      Static4D touchPoint = new Static4D(x, y, 0, 0);

      Static4D rotatedTouchPoint= RubikSurfaceView.rotateVectorByInvertedQuat(touchPoint, accumulated);

      mPoint[0] = rotatedTouchPoint.get1();

      mPoint[1] = rotatedTouchPoint.get2();

      mPoint[2] = rotatedTouchPoint.get3();

      }

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

    private void convertCameraPointToScreenSpace(Static4D accumulated, float cameraDistance)

      {

      Static4D cameraPoint = new Static4D(0, 0, cameraDistance, 0);

      Static4D rotatedCamera= RubikSurfaceView.rotateVectorByInvertedQuat(cameraPoint, accumulated);

      mCamera[0] = rotatedCamera.get1();

      mCamera[1] = rotatedCamera.get2();

      mCamera[2] = rotatedCamera.get3();

      }

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

// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace,

// cast this touch point onto the surface defined by the 'face' and write the cast coords to 'output'.

// Center of the 'face' = (0,0), third coord always +- cubeHalfSize.

    private void castTouchPointOntoFace(int face, float cubeHalfSize, float[] output)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceZaxis(face);

      float diff = mPoint[zAxis]-mCamera[zAxis];

      float ratio =  diff!=0.0f ? (sign*cubeHalfSize-mCamera[zAxis])/diff : 0.0f;

      output[0] = (mPoint[0]-mCamera[0])*ratio + mCamera[0];

      output[1] = (mPoint[1]-mCamera[1])*ratio + mCamera[1];

      output[2] = (mPoint[2]-mCamera[2])*ratio + mCamera[2];

      }

// PUBLIC API

    public RubikCubeMovement(RubikCube cube)

      mCube = cube;

      float cubeHalfSize= mCube.returnCubeSizeInScreenSpace()*0.5f;

    public void addNewRotation(Static4D accumulated, int lastTouchedFace, float x, float y)

      float cubeHalfSize= mCube.returnCubeSizeInScreenSpace()*0.5f;

      mCube.addNewRotation(mRotationVect, (int)(mCube.getSize()*offset) );

    public void continueRotation(Static4D accumulated, int lastTouchedFace, float x, float y, int scrMin)

      mCube.continueRotation(SWIPING_SENSITIVITY*sign*angle/scrMin);