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.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.util.AttributeSet;

import org.distorted.screens.RubikScreenPlay;

import org.distorted.screens.RubikScreenSolver;

import org.distorted.screens.RubikScreenSolving;

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

    public static final int MODE_DRAG    = 1;

    public static final int MODE_REPLACE = 2;

    // given face by SWIPING_SENSITIVITY/2 degrees.

    private final static int SWIPING_SENSITIVITY  = 240;

    private final static float ROTATION_SENSITIVITY = 0.3f;

    private float mAxisX, mAxisY;

    private float[] mLastY;

    private long[] mLastT;

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

    void setScreenSize(int width, int height)

      {

      mScreenWidth = width;

      mScreenHeight= height;

    boolean isVertical()

      {

      return mScreenHeight>mScreenWidth;

      }

    RubikRenderer getRenderer()

      {

      return mRenderer;

      }

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

      mMovement = movement;

      }

    private Static4D quatFromDrag(float dragX, float dragY)

      {

      float axisX = dragY;  // inverted X and Y - rotation axis is perpendicular to (dragX,dragY)

      float axisY = dragX;  // Why not (-dragY, dragX) ? because Y axis is also inverted!

      float axisZ = 0;

      float axisL = (float)Math.sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

      if( axisL>0 )

        {

        axisX /= axisL;

        axisY /= axisL;

        axisZ /= axisL;

        float ratio = axisL;

        ratio = ratio - (int)ratio;     // the cos() is only valid in (0,Pi)

        float cosA = (float)Math.cos(Math.PI*ratio);

        float sinA = (float)Math.sqrt(1-cosA*cosA);

        return new Static4D(axisX*sinA, axisY*sinA, axisZ*sinA, cosA);

        }

      return new Static4D(0f, 0f, 0f, 1f);

      }

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

      mAxisX =result.get0();

      mAxisY =result.get1();

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

      mAxisX /= len;

      mAxisY /= len;

      }

      float qy = quat1.get1();

      float qz = quat1.get2();

      float qw = quat1.get3();

      float ry = quat2.get1();

      float rz = quat2.get2();

      float rw = quat2.get3();

      float ty = rw*qy + rz*qx + ry*qw - rx*qz;

      float tz = rw*qz + rz*qw - ry*qx + rx*qy;

      float tw = rw*qw - rz*qz - ry*qy - rx*qx;

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

      float qy = quat.get1();

      float qz = quat.get2();

      float qw = quat.get3();

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

      float qy = quat.get1();

      float qz = quat.get2();

      float qw = quat.get3();

      long currTime = System.currentTimeMillis();

      boolean theSame = mLastIndex==mFirstIndex;

      mLastIndex++;

      if( mLastIndex>=NUM_SPEED_PROBES ) mLastIndex=0;

      mLastX[mLastIndex] = x;

      mLastY[mLastIndex] = y;

      if( mLastIndex==mFirstIndex)

        {

        mFirstIndex++;

        if( mFirstIndex>=NUM_SPEED_PROBES ) mFirstIndex=0;

        }

      if( theSame )

        {

        mLastX[mFirstIndex] = x;

        mLastY[mFirstIndex] = y;

      }

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

      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;

      float yDist = mScreenHeight*(yFrom-yTo);

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

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

    private void setUpDragOrRotate(boolean down, float x, float y)

      {

      if( mode==MODE_DRAG )

        {

        mDragging           = true;

        mBeginningRotation  = false;

        mContinuingRotation = false;

        }

      else

        {

        Static4D rotatedTouchPoint= rotateVectorByInvertedQuat(touchPoint, mQuat);

          mDragging           = false;

          mContinuingRotation = false;

          if( mode==MODE_ROTATE )

            {

            mBeginningRotation= mPreRender.canRotate();

            }

          else if( mode==MODE_REPLACE )

            {

            mBeginningRotation= false;

            if( down )

              {

              float[] point = mMovement.getTouchedPoint3D();

              int color = solver.getCurrentColor();

              mLastCubit = object.getCubit(point);

              mPreRender.setTextureMap( mLastCubit, mLastCubitFace, color );

            }

          }

        else

          {

          mDragging           = !act.isLocked();

          mContinuingRotation = false;

          }

        }

      }

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

        {

        int pointer = event.findPointerIndex(mPtrID2);

          {

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

      else

        {

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

        mTemp.set(dragQuat);

        }

      mX = x;

      mY = y;

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

    private void finishRotation()

      {

      computeCurrentSpeedInInchesPerSecond();

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

      mPreRender.finishRotation(angle);

          }

          }

      mContinuingRotation = false;

      mBeginningRotation  = false;

      mDragging           = true;

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

      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;

      mPreRender.getObject().continueRotation(mCurrentAngle);

      mStartRotX = x;

      mStartRotY = y;

        final RubikActivity act = (RubikActivity)getContext();

          {

          @Override

          public void run()

            {

          });

      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)

      {

      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 )

        }

        {

        continueRotation(x,y);

        }

      else if( mDragging )

        {

        {

      }

    private void actionDown(MotionEvent event)

      {

      float y = event.getY();

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

      setUpDragOrRotate(true,mX,mY);

      }

      mPtrID2 = INVALID_POINTER_ID;

      if( mContinuingRotation )

        {

      if( mLastCubitColor>=0 )

        {

        mPreRender.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );

      }

    private void actionDown2(MotionEvent event)

      {

      if( mPtrID1==INVALID_POINTER_ID )

        {

        mPtrID1 = event.getPointerId(index);

        float y = event.getY();

        if( mPtrID2 != INVALID_POINTER_ID )

          {

          int pointer = event.findPointerIndex(mPtrID2);

            {

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

            }

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

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

        }

      else if( mPtrID2==INVALID_POINTER_ID )

        {

        mPtrID2 = event.getPointerId(index);

        float y = event.getY();

        if( mPtrID2 != INVALID_POINTER_ID )

            {

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

            }

        if( mBeginningRotation || mContinuingRotation )

          {

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

          }

        }

        {

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      else if( mContinuingRotation )

        {

        finishRotation();

        }

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

        mPtrID1 = INVALID_POINTER_ID;

        int pointer = event.findPointerIndex(mPtrID2);