Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

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

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.main;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.opengl.GLSurfaceView;

import android.util.AttributeSet;

import android.util.DisplayMetrics;

import android.view.MotionEvent;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectMovement;

import org.distorted.solvers.SolverMain;

import org.distorted.states.RubikState;

import org.distorted.states.RubikStateSolver;

import org.distorted.states.RubikStateSolving;

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

public class RubikSurfaceView extends GLSurfaceView

{

    private static final int NUM_SPEED_PROBES = 10;

    private static final int INVALID_POINTER_ID = -1;

    public static final int MODE_ROTATE  = 0;

    public static final int MODE_DRAG    = 1;

    public static final int MODE_REPLACE = 2;

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

    // Moving the finger by 0.33 of an inch will start a Rotation.

    private final static float ROTATION_SENSITIVITY =  0.33f;

    // Every 0.33 of an inch the direction of cube drag will reset.

    private final static float DIRECTION_SENSITIVITY=  0.33f;

    // Where did we get this sqrt(3)/2 ? From the (default, i.e. 60 degrees - see InternalOutputSurface!)

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

    private RubikPreRender mPreRender;

    private RubikObjectMovement mMovement;

    private boolean mDragging, mBeginningRotation, mContinuingRotation;

    private int mScreenWidth, mScreenHeight, mScreenMin;

    private int mPtrID1, mPtrID2;

    private float mX, mY, mBegX1, mBegY1, mBegX2, mBegY2;

    private float mStartRotX, mStartRotY;

    private float mAxisX, mAxisY;

    private float mRotationFactor;

    private int mLastCubitColor, mLastCubitFace, mLastCubit;

    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 Static4D mQuatCurrent    = new Static4D(0,0,0,1);

    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;

      mScreenMin = Math.min(width, height);

      }

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

    boolean isVertical()

      {

      return mScreenHeight>mScreenWidth;

      }

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

    RubikRenderer getRenderer()

      {

      return mRenderer;

      }

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

    RubikPreRender getPreRender()

      {

      return mPreRender;

      }

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

    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 quatFromAngle(float angle)

      {

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

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

      return new Static4D(0, 0, sinA, cosA);

      }

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

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

      }

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

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

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

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

      return (tmp>0 ? 1:-1)*len*mRotationFactor;

      }

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

// return quat1*quat2

    public static Static4D quatMultiply( Static4D quat1, Static4D quat2 )

      {

      float qx = quat1.get0();

      float qy = quat1.get1();

      float qz = quat1.get2();

      float qw = quat1.get3();

      float rx = quat2.get0();

      float ry = quat2.get1();

      float rz = quat2.get2();

      float rw = quat2.get3();

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

      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;

      return new Static4D(tx,ty,tz,tw);

      }

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

// rotate 'vector' by quat  ( i.e. return quat*vector*(quat^-1) )

    public static Static4D rotateVectorByQuat(Static4D vector, Static4D quat)

      {

      float qx = quat.get0();

      float qy = quat.get1();

      float qz = quat.get2();

      float qw = quat.get3();

      Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw);

      Static4D tmp = quatMultiply(quat,vector);

      return quatMultiply(tmp,quatInverted);

      }

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

// rotate 'vector' by quat^(-1)  ( i.e. return (quat^-1)*vector*quat )

    public static Static4D rotateVectorByInvertedQuat(Static4D vector, Static4D quat)

      {

      float qx = quat.get0();

      float qy = quat.get1();

      float qz = quat.get2();

      float qw = quat.get3();

      Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw);

      Static4D tmp = quatMultiply(quatInverted,vector);

      return quatMultiply(tmp,quat);

      }

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

    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(boolean down, float x, float y)

      {

      int mode = RubikState.getMode();

      if( mode==MODE_DRAG )

        {

        mDragging           = true;

        mBeginningRotation  = false;

        mContinuingRotation = false;

        }

      else

        {

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

        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= mPreRender.canRotate();

            }

          else if( mode==MODE_REPLACE )

            {

            mBeginningRotation= false;

            if( down )

              {

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

              mLastCubitFace = mMovement.getTouchedFace();

              float[] point = mMovement.getTouchedPoint3D();

              int color = solver.getCurrentColor();

              RubikObject object = mPreRender.getObject();

              mLastCubit = object.getCubit(point);

              mPreRender.setTextureMap( mLastCubit, mLastCubitFace, color );

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

              }

            }

          }

        else

          {

          mDragging           = true;

          mBeginningRotation  = false;

          mContinuingRotation = false;

          }

        }

      }

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

    private void dragging(float x, float y)

      {

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

      mPreRender.setQuatCurrentOnNextRender();

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

        {

        mX = x;

        mY = y;

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

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

        mPreRender.setQuatCurrentOnNextRender();

        mPreRender.setQuatAccumulatedOnNextRender();

        }

      }

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

    private void continuingRotation(float x, float y)

      {

      float angle = continueRotation(x-mStartRotX,y-mStartRotY);

      mCurrentAngle = SWIPING_SENSITIVITY*angle;

      mPreRender.getObject().continueRotation(mCurrentAngle);

      addSpeedProbe(x,y);

      }

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

    private void beginningRotation(float x, float y)

      {

      mStartRotX = x;

      mStartRotY = y;

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

      Static4D rotatedTouchPoint2= rotateVectorByInvertedQuat(touchPoint2, mQuatAccumulated);

      Static2D res = mMovement.newRotation(rotatedTouchPoint2);

      RubikObject object = mPreRender.getObject();

      mCurrentAxis = (int)res.get0();

      float offset = res.get1();

      mCurrentRow = (int)(object.returnMultiplier()*offset);

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

      mRotationFactor = object.returnRotationFactor(offset);

      object.beginNewRotation( mCurrentAxis, mCurrentRow );

      if( RubikState.getCurrentState()==RubikState.READ )

        {

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

        solving.resetElapsed();

        final RubikActivity act = (RubikActivity)getContext();

        act.runOnUiThread(new Runnable()

          {

          @Override

          public void run()

            {

            RubikState.switchState( act, RubikState.SOLV);

            }

          });

        }

      addSpeedProbe(x,y);

      mBeginningRotation = false;

      mContinuingRotation= true;

      }

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

    private void actionMove(MotionEvent event)

      {

      if( mPtrID2 == INVALID_POINTER_ID )

        {

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

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

        if( mBeginningRotation )

          {

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

            {

            beginningRotation(x,y);

            }

          }

        else if( mContinuingRotation )

          {

          continuingRotation(x,y);

          }

        else if( mDragging )

          {

          dragging(x,y);

          }

        else

          {

          setUpDragOrRotate(false,x,y);

          }

        }

      else

        {

        int index1 = event.findPointerIndex(mPtrID1);

        int index2 = event.findPointerIndex(mPtrID2);

        float nX1 = event.getX(index1);

        float nY1 = event.getY(index1);

        float nX2 = event.getX(index2);

        float nY2 = event.getY(index2);

        float angle1 = (float) Math.atan2(mBegY1-mBegY2, mBegX1-mBegX2);

        float angle2 = (float) Math.atan2( nY1-nY2     , nX1-nX2      );

        mTempCurrent.set(quatFromAngle(angle1-angle2));

        mPreRender.setQuatCurrentOnNextRender();

        }

      }

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

    private void actionDown(MotionEvent event)

      {

      mPtrID1 = event.getPointerId(0);

      mX = (event.getX() - mScreenWidth*0.5f)/mScreenMin;

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

      setUpDragOrRotate(true,mX,mY);

      }

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

    private void actionUp()

      {

      mPtrID1 = INVALID_POINTER_ID;

      if( mDragging )

        {

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

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

        mPreRender.setQuatCurrentOnNextRender();

        mPreRender.setQuatAccumulatedOnNextRender();

        }

      if( mContinuingRotation )

        {

        computeCurrentSpeedInInchesPerSecond();

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

        mPreRender.finishRotation(angle);

        if( RubikState.getCurrentState()==RubikState.SOLV && angle!=0 )

          {

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

          solving.addMove(mCurrentAxis, mCurrentRow, angle);

          }

        }

      if( mLastCubitColor>=0 )

        {

        mPreRender.setTextureMap( mLastCubit, mLastCubitFace, mLastCubitColor );

        }

      }

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

    private void actionDown2(MotionEvent event)

      {

      mPtrID2 = event.getPointerId(event.getActionIndex());

      int index1 = event.findPointerIndex(mPtrID1);

      mBegX1 = event.getX(index1);

      mBegY1 = event.getY(index1);

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

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

      int index2 = event.findPointerIndex(mPtrID2);

      mBegX2 = event.getX(index2);

      mBegY2 = event.getY(index2);

      }

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

    private void actionUp2()

      {

      mPtrID2 = INVALID_POINTER_ID;

      }

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

// PUBLIC API

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

    public RubikSurfaceView(Context context, AttributeSet attrs)

      {

      super(context,attrs);

      if(!isInEditMode())

        {

        mLastCubitColor = -1;

        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;

        mPtrID1 = INVALID_POINTER_ID;

        mPtrID2 = INVALID_POINTER_ID;

        mRenderer  = new RubikRenderer(this);

        mPreRender = new RubikPreRender(this);

        RubikActivity act = (RubikActivity)context;

        DisplayMetrics dm = new DisplayMetrics();

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

        mDensity = dm.densityDpi;

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

        if( activityManager!=null )

          {

          final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

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

          setRenderer(mRenderer);

          }

        }

      }

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

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

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

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

         case MotionEvent.ACTION_POINTER_UP  : actionUp2()       ; break;

         }

      return true;

      }

}