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.opengl.GLSurfaceView;

import android.util.AttributeSet;

import android.view.MotionEvent;

import org.distorted.objects.RubikObjectMovement;

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

    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 int ROTATION_SENSITIVITY =  15;

    private final static int DIRECTION_SENSITIVITY=  12;

    // FOV of the projection matrix of the Node onto the Screen.

    // Take a look how the CAMERA_POINT is used in onTouchEvent - (x,y) there are expressed in sort of

    // 'half-NDC' coordinates i.e. they range from +0.5 to -0.5; thus CAMERA_POINT also needs to be

    // in 'half-NDC'. Since in this coordinate system the height of the screen is equal to 1, then the

    // Z-distance from the center of the object to the camera is equal to (scrHeight/2)/tan(FOV/2) =

    // 0.5/tan(30) = sqrt(3)/2.

    // Why is the Z-distance between the camera and the object equal to (scrHeight/2)/tan(FOV/2)?

    // Because of the way the View part of the ModelView matrix is constructed in EffectQueueMatrix.send().

    private final Static4D CAMERA_POINT = new Static4D(0, 0, (float)Math.sqrt(3)*0.5f, 0);

    private float mStartRotX, mStartRotY;

    private float mAxisX, mAxisY;

    private float mCurrentAngle;

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

    private static Static4D mTempCurrent    = new Static4D(0,0,0,1);

    private static Static4D mTempAccumulated= 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;

      }

    RubikPostRender getPostRender()

      {

      return mPostRender;

      }

    void setQuatAccumulated()

      {

      mQuatAccumulated.set(mTempAccumulated);

      }

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

    void setQuatCurrent()

      {

      mQuatCurrent.set(mTempCurrent);

      }

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

    Static4D getQuatAccumulated()

      {

      return mQuatAccumulated;

      }

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

    Static4D getQuatCurrent()

      {

      return mQuatCurrent;

      }

    void setMovement(RubikObjectMovement movement)

      {

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

      }

      if( mode==MODE_DRAG )

        mBeginningRotation  = false;

        }

      else

        {

        Static4D rotatedTouchPoint1= rotateVectorByInvertedQuat(touchPoint1, mQuatAccumulated);

        Static4D rotatedCamera= rotateVectorByInvertedQuat(CAMERA_POINT, mQuatAccumulated);

        if( mMovement!=null && mMovement.faceTouched(rotatedTouchPoint1,rotatedCamera) )

          {

          mDragging           = false;

          mContinuingRotation = false;

          if( mode==MODE_ROTATE )

            {

            mBeginningRotation= mPostRender.canRotate();

            }

          else if( mode==MODE_REPLACE )

            {

            mBeginningRotation= false;

            if( down )

              {

              RubikStateSolver solver = (RubikStateSolver) RubikState.SVER.getStateClass();

              int color = solver.getCurrentColor();

              RubikObject object = mPostRender.getObject();

              mPostRender.setTextureMap( mLastCubit, mLastCubitFace, color );

              mLastCubitColor = SolverMain.cubitIsLocked(object.getObjectList(), object.getSize(), mLastCubit);

        else

          {

          mContinuingRotation = false;

          }

      }

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

// cast the 3D axis we are currently rotating along to the 2D in-screen-surface axis

    private void computeCurrentAxis(Static3D axis)

      {

      Static4D axis4D = new Static4D(axis.get0(), axis.get1(), axis.get2(), 0);

      Static4D result = rotateVectorByQuat(axis4D, mQuatAccumulated);

      mAxisX =result.get0();

      mAxisY =result.get1();

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

      mAxisX /= len;

      mAxisY /= len;

      }

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

    private float continueRotation(float dx, float dy)

      {

      float alpha = dx*mAxisX + dy*mAxisY;

      float x = dx - alpha*mAxisX;

      float y = dy - alpha*mAxisY;

      float len = (float)Math.sqrt(x*x + y*y);

      float tmp = mAxisY==0 ? -mAxisX*y : mAxisY*x;

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

// PUBLIC API

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

    public RubikSurfaceView(Context context, AttributeSet attrs)

      {

      super(context,attrs);

      if(!isInEditMode())

        {

        mPostRender = new RubikPostRender(this);

        final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

        setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );

        setRenderer(mRenderer);

        }

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      int action = event.getAction();

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

      switch(action)

         {

         case MotionEvent.ACTION_DOWN: mX = x;

                                       mY = y;

                                           mStartRotY = y;

                                           Static4D rotatedTouchPoint2= rotateVectorByInvertedQuat(touchPoint2, mQuatAccumulated);

                                           computeCurrentAxis( object.getRotationAxis()[mCurrentAxis] );

                                             {

                                             RubikStateSolving solving = (RubikStateSolving)RubikState.SOLV.getStateClass();

                                             solving.startCounting( (RubikActivity)getContext() );

                                             }

                                           mContinuingRotation= true;

                                           }

                                         }

                                       else if( mContinuingRotation )

                                         {

                                         mPostRender.getObject().continueRotation(mCurrentAngle);

                                         mTempCurrent.set(quatFromDrag(mX-x,y-mY));

                                         if( (mX-x)*(mX-x) + (mY-y)*(mY-y) > 1.0f/(DIRECTION_SENSITIVITY*DIRECTION_SENSITIVITY) )

                                           {

                                           mX = x;

                                           mY = y;

                                           mTempAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated));

                                           mTempCurrent.set(0f, 0f, 0f, 1f);

                                           mPostRender.setQuatAccumulatedOnNextRender();

                                         }

         case MotionEvent.ACTION_UP  : if( mDragging )

                                         {

                                         mTempAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated));

                                         mTempCurrent.set(0f, 0f, 0f, 1f);

                                         mPostRender.setQuatAccumulatedOnNextRender();

                                       if( mContinuingRotation )

                                         {

                                         if( RubikState.getCurrentState()==RubikState.SOLV )

                                           {

                                           RubikStateSolving solving = (RubikStateSolving)RubikState.SOLV.getStateClass();

                                           int angle = mPostRender.getObject().computeNearestAngle(mCurrentAngle);

                                           if( angle!=0 )

                                             solving.addMove(mCurrentAxis, mCurrentRow, angle);

                                           }

                                         {

                                          mPostRender.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );

                                         }

         }

      return true;

      }