Magic Cube

import android.util.DisplayMetrics;

import org.distorted.library.type.Static2D;

import org.distorted.library.main.QuatHelper;

import org.distorted.objectlib.main.TwistyObject;

import static org.distorted.main.RubikSurfaceView.INVALID_POINTER_ID;

import static org.distorted.main.RubikSurfaceView.NUM_SPEED_PROBES;

import static org.distorted.main.RubikSurfaceView.ROTATION_SENSITIVITY;

import static org.distorted.main.RubikSurfaceView.SWIPING_SENSITIVITY;

    private final Static4D CAMERA_POINT = new Static4D(0, 0, 0, 0);

    private ObjectPreRender mPreRender;

    private Movement mMovement;

    private boolean mDragging, mBeginningRotation, mContinuingRotation;

    private int mScreenWidth, mScreenHeight, mScreenMin;

    private float mRotAngle, mInitDistance;

    private int mPtrID1, mPtrID2;

    private float mX, mY;

    private float mStartRotX, mStartRotY;

    private float mAxisX, mAxisY;

    private float mRotationFactor;

    private int mCurrentAxis, mCurrentRow;

    private float mCurrentAngle, mCurrRotSpeed;

    private float[] mLastX;

    private float[] mLastY;

    private long[] mLastT;

    private int mFirstIndex, mLastIndex;

    private int mDensity;

    private static final Static4D mQuat= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);

    private static final Static4D mTemp= new Static4D(0,0,0,1);

      mScreenMin = Math.min(width, height);

    ObjectPreRender getPreRender()

      {

      return mPreRender;

      }

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

// cast the 3D axis we are currently rotating along (which is already casted to the surface of the

// currently touched face AND converted into a 4D vector - fourth 0) to a 2D in-screen-surface axis

    private void computeCurrentAxis(Static4D axis)

      {

      Static4D result = QuatHelper.rotateVectorByQuat(axis, mQuat);

      mAxisX =result.get0();

      mAxisY =result.get1();

      float len = (float)Math.sqrt(mAxisX*mAxisX + mAxisY*mAxisY);

      mAxisX /= len;

      mAxisY /= len;

      }

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

    private void addSpeedProbe(float x, float y)

      {

      long currTime = System.currentTimeMillis();

      boolean theSame = mLastIndex==mFirstIndex;

      mLastIndex++;

      if( mLastIndex>=NUM_SPEED_PROBES ) mLastIndex=0;

      mLastT[mLastIndex] = currTime;

      mLastX[mLastIndex] = x;

      mLastY[mLastIndex] = y;

      if( mLastIndex==mFirstIndex)

        {

        mFirstIndex++;

        if( mFirstIndex>=NUM_SPEED_PROBES ) mFirstIndex=0;

        }

      if( theSame )

        {

        mLastT[mFirstIndex] = currTime;

        mLastX[mFirstIndex] = x;

        mLastY[mFirstIndex] = y;

        }

      }

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

    private void computeCurrentSpeedInInchesPerSecond()

      {

      long firstTime = mLastT[mFirstIndex];

      long lastTime  = mLastT[mLastIndex];

      float fX = mLastX[mFirstIndex];

      float fY = mLastY[mFirstIndex];

      float lX = mLastX[mLastIndex];

      float lY = mLastY[mLastIndex];

      long timeDiff = lastTime-firstTime;

      mLastIndex = 0;

      mFirstIndex= 0;

      mCurrRotSpeed = timeDiff>0 ? 1000*retFingerDragDistanceInInches(fX,fY,lX,lY)/timeDiff : 0;

      }

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

    private float retFingerDragDistanceInInches(float xFrom, float yFrom, float xTo, float yTo)

      {

      float xDist = mScreenWidth*(xFrom-xTo);

      float yDist = mScreenHeight*(yFrom-yTo);

      float distInPixels = (float)Math.sqrt(xDist*xDist + yDist*yDist);

      return distInPixels/mDensity;

      }

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

    private void setUpDragOrRotate(float x, float y)

      {

      TwistyObject object = mPreRender.getObject();

      CAMERA_POINT.set2( object==null ? 1.21f : object.getCameraDist() );

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

      Static4D rotatedTouchPoint= QuatHelper.rotateVectorByInvertedQuat(touchPoint, mQuat);

      Static4D rotatedCamera= QuatHelper.rotateVectorByInvertedQuat(CAMERA_POINT, mQuat);

      if( mMovement!=null && mMovement.faceTouched(rotatedTouchPoint,rotatedCamera,object.getObjectRatio()) )

        {

        mDragging           = false;

        mContinuingRotation = false;

        mBeginningRotation= !mPreRender.isTouchBlocked();

        }

      else

        {

        final TutorialActivity act = (TutorialActivity)getContext();

        boolean locked      = act.isLocked();

        mDragging           = !locked;

        mContinuingRotation = false;

        mBeginningRotation  = false;

        if( !mDragging )

          {

          TutorialState state = act.getState();

          state.reddenLock(act);

          }

        }

      }

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

    private void drag(MotionEvent event, float x, float y)

      {

      if( mPtrID1!=INVALID_POINTER_ID && mPtrID2!=INVALID_POINTER_ID)

        {

        int pointer = event.findPointerIndex(mPtrID2);

        float pX,pY;

        try

          {

          pX = event.getX(pointer);

          pY = event.getY(pointer);

          }

        catch(IllegalArgumentException ex)

          {

          mPtrID1=INVALID_POINTER_ID;

          mPtrID2=INVALID_POINTER_ID;

          FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

          crashlytics.setCustomKey("DragError", "pointer="+pointer );

          crashlytics.recordException(ex);

          return;

          }

        float x2 = (pX - mScreenWidth*0.5f)/mScreenMin;

        float y2 = (mScreenHeight*0.5f -pY)/mScreenMin;

        float angleNow = getAngle(x,y,x2,y2);

        float angleDiff = angleNow-mRotAngle;

        float sinA =-(float)Math.sin(angleDiff);

        float cosA = (float)Math.cos(angleDiff);

        Static4D dragQuat = QuatHelper.quatMultiply(new Static4D(0,0,sinA,cosA), mQuat);

        mTemp.set(dragQuat);

        mRotAngle = angleNow;

        float distNow  = (float)Math.sqrt( (x-x2)*(x-x2) + (y-y2)*(y-y2) );

        float distQuot = mInitDistance<0 ? 1.0f : distNow/ mInitDistance;

        mInitDistance = distNow;

        TwistyObject object = mPreRender.getObject();

        if( object!=null ) object.setObjectRatio(distQuot);

        }

      else

        {

        Static4D dragQuat = QuatHelper.quatMultiply(QuatHelper.quatFromDrag(mX-x,y-mY), mQuat);

        mTemp.set(dragQuat);

        }

      mPreRender.setQuatOnNextRender();

      mX = x;

      mY = y;

      }

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

    private void finishRotation()

      {

      computeCurrentSpeedInInchesPerSecond();

      int angle = mPreRender.getObject().computeNearestAngle(mCurrentAxis,mCurrentAngle, mCurrRotSpeed);

      mPreRender.finishRotation(angle);

      if( angle!=0 )

        {

        final TutorialActivity act = (TutorialActivity)getContext();

        TutorialState state = act.getState();

        state.addMove(act,mCurrentAxis, mCurrentRow, angle);

        }

      mContinuingRotation = false;

      mBeginningRotation  = false;

      mDragging           = true;

      }

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

    private void continueRotation(float x, float y)

      {

      float dx = x-mStartRotX;

      float dy = y-mStartRotY;

      float alpha = dx*mAxisX + dy*mAxisY;

      float x2 = dx - alpha*mAxisX;

      float y2 = dy - alpha*mAxisY;

      float len = (float)Math.sqrt(x2*x2 + y2*y2);

      // we have the length of 1D vector 'angle', now the direction:

      float tmp = mAxisY==0 ? -mAxisX*y2 : mAxisY*x2;

      float angle = (tmp>0 ? 1:-1)*len*mRotationFactor;

      mCurrentAngle = SWIPING_SENSITIVITY*angle;

      mPreRender.getObject().continueRotation(mCurrentAngle);

      addSpeedProbe(x2,y2);

      }

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

    private void beginRotation(float x, float y)

      {

      mStartRotX = x;

      mStartRotY = y;

      TwistyObject object = mPreRender.getObject();

      int numLayers = object.getNumLayers();

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

      Static4D rotatedTouchPoint2= QuatHelper.rotateVectorByInvertedQuat(touchPoint2, mQuat);

      Static2D res = mMovement.newRotation(rotatedTouchPoint2,object.getObjectRatio());

      mCurrentAxis = (int)res.get0();

      mCurrentRow  = (int)res.get1();

      computeCurrentAxis( mMovement.getCastedRotAxis(mCurrentAxis) );

      mRotationFactor = mMovement.returnRotationFactor(numLayers,mCurrentRow);

      object.beginNewRotation( mCurrentAxis, mCurrentRow );

      addSpeedProbe(x,y);

      mBeginningRotation = false;

      mContinuingRotation= true;

      }

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

    private float getAngle(float x1, float y1, float x2, float y2)

      return (float) Math.atan2(y1-y2, x1-x2);

    private void actionMove(MotionEvent event)

      {

      int pointer = event.findPointerIndex(mPtrID1 != INVALID_POINTER_ID ? mPtrID1:mPtrID2);

      if( pointer<0 ) return;

      float pX = event.getX(pointer);

      float pY = event.getY(pointer);

      float x = (pX - mScreenWidth*0.5f)/mScreenMin;

      float y = (mScreenHeight*0.5f -pY)/mScreenMin;

      if( mBeginningRotation )

        {

        if( retFingerDragDistanceInInches(mX,mY,x,y) > ROTATION_SENSITIVITY )

          {

          beginRotation(x,y);

          }

        }

      else if( mContinuingRotation )

        {

        continueRotation(x,y);

        }

      else if( mDragging )

        {

        drag(event,x,y);

        }

      else

        {

        setUpDragOrRotate(x,y);

        }

      }

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

    private void actionDown(MotionEvent event)

      {

      mPtrID1 = event.getPointerId(0);

      float x = event.getX();

      float y = event.getY();

      mX = (x - mScreenWidth*0.5f)/mScreenMin;

      mY = (mScreenHeight*0.5f -y)/mScreenMin;

      setUpDragOrRotate(mX,mY);

      }

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

    private void actionUp(MotionEvent event)

      {

      mPtrID1 = INVALID_POINTER_ID;

      mPtrID2 = INVALID_POINTER_ID;

      if( mContinuingRotation )

        {

        finishRotation();

        }

      }

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

    private void actionDown2(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( mPtrID1==INVALID_POINTER_ID )

        {

        mPtrID1 = event.getPointerId(index);

        float x = event.getX();

        float y = event.getY();

        if( mPtrID2 != INVALID_POINTER_ID )

          {

          int pointer = event.findPointerIndex(mPtrID2);

          try

            {

            float x2 = event.getX(pointer);

            float y2 = event.getY(pointer);

            mRotAngle = getAngle(x,-y,x2,-y2);

            mInitDistance = -1;

            }

          catch(IllegalArgumentException ex)

            {

            mPtrID1=INVALID_POINTER_ID;

            mPtrID2=INVALID_POINTER_ID;

            FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

            crashlytics.setCustomKey("DragError", "pointer="+pointer );

            crashlytics.recordException(ex);

            return;

            }

          }

        mX = (x - mScreenWidth*0.5f)/mScreenMin;

        mY = (mScreenHeight*0.5f -y)/mScreenMin;

        }

      else if( mPtrID2==INVALID_POINTER_ID )

        {

        mPtrID2 = event.getPointerId(index);

        float x = event.getX();

        float y = event.getY();

        if( mPtrID2 != INVALID_POINTER_ID )

          {

          int pointer = event.findPointerIndex(mPtrID2);

          try

            {

            float x2 = event.getX(pointer);

            float y2 = event.getY(pointer);

            mRotAngle = getAngle(x,-y,x2,-y2);

            mInitDistance = -1;

            }

          catch(IllegalArgumentException ex)

            {

            mPtrID1=INVALID_POINTER_ID;

            mPtrID2=INVALID_POINTER_ID;

            FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

            crashlytics.setCustomKey("DragError", "pointer="+pointer );

            crashlytics.recordException(ex);

            return;

            }

          }

        if( mBeginningRotation || mContinuingRotation )

          {

          mX = (x - mScreenWidth*0.5f)/mScreenMin;

          mY = (mScreenHeight*0.5f -y)/mScreenMin;

          }

        }

      if( mBeginningRotation )

        {

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      else if( mContinuingRotation )

        {

        finishRotation();

        }

      }

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

    private void actionUp2(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( index==event.findPointerIndex(mPtrID1) )

        {

        mPtrID1 = INVALID_POINTER_ID;

        int pointer = event.findPointerIndex(mPtrID2);

        if( pointer>=0 )

          {

          float x1 = event.getX(pointer);

          float y1 = event.getY(pointer);

          mX = (x1 - mScreenWidth*0.5f)/mScreenMin;

          mY = (mScreenHeight*0.5f -y1)/mScreenMin;

          }

        }

      else if( index==event.findPointerIndex(mPtrID2) )

        {

        mPtrID2 = INVALID_POINTER_ID;

        }

      }

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

    void initialize()

      mPtrID1 = INVALID_POINTER_ID;

      mPtrID2 = INVALID_POINTER_ID;

        mCurrRotSpeed= 0.0f;

        mLastX = new float[NUM_SPEED_PROBES];

        mLastY = new float[NUM_SPEED_PROBES];

        mLastT = new long[NUM_SPEED_PROBES];

        mFirstIndex =0;

        mLastIndex  =0;

        mRenderer  = new TutorialRenderer(this);

        mPreRender = new ObjectPreRender(this,new TutorialObjectStateActioner());

        DisplayMetrics dm = new DisplayMetrics();

        act.getWindowManager().getDefaultDisplay().getMetrics(dm);

        mDensity = dm.densityDpi;

          crashlytics.setCustomKey("GLversion"     , version );

          crashlytics.setCustomKey("GLSLrenderer"  , renderer);

    public void setQuat()

      mQuat.set(mTemp);

    public Static4D getQuat()

      return mQuat;

    public void setMovement(Movement movement)

      mMovement = movement;

      int action = event.getActionMasked();

      switch(action)

         {

         case MotionEvent.ACTION_DOWN        : actionDown(event) ; break;

         case MotionEvent.ACTION_MOVE        : actionMove(event) ; break;

         case MotionEvent.ACTION_UP          : actionUp(event)   ; break;

         case MotionEvent.ACTION_POINTER_DOWN: actionDown2(event); break;

         case MotionEvent.ACTION_POINTER_UP  : actionUp2(event)  ; break;

         }

      return true;