Magic Cube

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

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

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

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

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

package org.distorted.main;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import android.util.DisplayMetrics;

import android.view.MotionEvent;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static4D;

import org.distorted.objects.TwistyObject;

import org.distorted.objects.Movement;

import org.distorted.screens.RubikScreenReady;

import org.distorted.solvers.SolverMain;

import org.distorted.screens.ScreenList;

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;

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

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

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

    private RubikRenderer mRenderer;

    private RubikPreRender mPreRender;

    private Movement mMovement;

    private boolean mDragging, mBeginningRotation, mContinuingRotation;

    private int mScreenWidth, mScreenHeight, mScreenMin;

    private float mRotAngle, mInitDistance;

    private float mStartRotX, mStartRotY;

    private float mRotationFactor;

    private int mLastCubitColor, mLastCubitFace, mLastCubit;

    private int mCurrentAxis, mCurrentRow;

    private float mCurrentAngle, mCurrRotSpeed;

    private float[] mLastX;

    private int mFirstIndex, mLastIndex;

    private int mDensity;

    private int mPointer1, mPointer2;

    private boolean mIsAutomatic;

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

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

      mScreenMin = Math.min(width, height);

      }

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

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

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

    RubikPreRender getPreRender()

      {

      return mPreRender;

      }

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

    void setQuat()

      {

      mQuat.set(mTemp);

      }

    Static4D getQuat()

      {

      return mQuat;

      }

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

    void setMovement(Movement movement)

      {

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

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

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

    private void computeCurrentAxis(Static4D axis)

      {

      Static4D result = rotateVectorByQuat(axis, mQuat);

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

// return quat1*quat2

    public static Static4D quatMultiply( Static4D quat1, Static4D quat2 )

      {

      float qx = quat1.get0();

      float rx = quat2.get0();

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

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

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

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

      Static4D tmp = quatMultiply(quatInverted,vector);

      return quatMultiply(tmp,quat);

      }

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

    private void addSpeedProbe(float x, float y)

      {

      mLastT[mLastIndex] = currTime;

        mLastT[mFirstIndex] = currTime;

        }

    private void computeCurrentSpeedInInchesPerSecond()

      {

      long firstTime = mLastT[mFirstIndex];

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

      return distInPixels/mDensity;

      }

      int mode = ScreenList.getMode();

        TwistyObject object = mPreRender.getObject();

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

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

        Static4D rotatedCamera= rotateVectorByInvertedQuat(CAMERA_POINT, mQuat);

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

          {

            mBeginningRotation= !mPreRender.isTouchBlocked();

            }

              RubikScreenSolver solver = (RubikScreenSolver) ScreenList.SVER.getScreenClass();

              mLastCubitFace = mMovement.getTouchedFace();

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

              }

          final RubikActivity act = (RubikActivity)getContext();

          final boolean locked= act.isLocked();

          mBeginningRotation  = false;

          if( !mDragging ) reddenLockIcon(act);

          }

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

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

    private void drag(float x, float y)

      {

      if( mPointer1!=INVALID_POINTER_ID && mPointer2!=INVALID_POINTER_ID)

        {

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

        TwistyObject object = mPreRender.getObject();

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

        }

      mPreRender.setQuatOnNextRender();

      }

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

      mPreRender.finishRotation(angle);

      mPreRender.rememberMove(mCurrentAxis,mCurrentRow,angle);

      if( angle!=0 )

        {

        if( ScreenList.getCurrentScreen()== ScreenList.SOLV )

          {

          RubikActivity act = (RubikActivity)getContext();

          RubikScreenSolving solving = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

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

          }

        if( ScreenList.getCurrentScreen()== ScreenList.PLAY )

          {

          RubikActivity act = (RubikActivity)getContext();

          RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();

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

          }

        }

      }

    private void continueRotation(float x, float y)

      {

      float dx = x-mStartRotX;

      mCurrentAngle = SWIPING_SENSITIVITY*angle;

      addSpeedProbe(x2,y2);

      }

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

    private void beginRotation(float x, float y)

      {

      TwistyObject object = mPreRender.getObject();

      int numLayers = object.getNumLayers();

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

      Static4D rotatedTouchPoint2= rotateVectorByInvertedQuat(touchPoint2, mQuat);

      Static2D res = mMovement.newRotation(numLayers,rotatedTouchPoint2);

      mCurrentAxis = (int)res.get0();

      mCurrentRow  = (int)res.get1();

      computeCurrentAxis( mMovement.getCastedRotAxis(mCurrentAxis) );

      mRotationFactor = mMovement.returnRotationFactor(numLayers,mCurrentRow);

      object.beginNewRotation( mCurrentAxis, mCurrentRow );

      if( ScreenList.getCurrentScreen()== ScreenList.READ )

        {

        RubikScreenSolving solving = (RubikScreenSolving) ScreenList.SOLV.getScreenClass();

        solving.resetElapsed();

        act.runOnUiThread(new Runnable()

            ScreenList.switchScreen( act, ScreenList.SOLV);

            }

        }

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

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

    void initialize()

      {

      mPointer1 = INVALID_POINTER_ID;

      }

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

    private void prepareDown(MotionEvent event)

      {

      mPointer1 = event.getPointerId(0);

      }

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

    private void prepareMove(MotionEvent event)

      {

      int index1 = event.findPointerIndex(mPointer1);

      if( index1>=0 )

        {

        mX1 = event.getX(index1);

        }

      int index2 = event.findPointerIndex(mPointer2);

        {

        mX2 = event.getX(index2);

        }

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

    private void prepareUp(MotionEvent event)

      {

      mPointer1 = INVALID_POINTER_ID;

      }

    private void prepareDown2(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( mPointer1==INVALID_POINTER_ID )

        {

        mPointer1 = event.getPointerId(index);

        }

      else if( mPointer2==INVALID_POINTER_ID )

        {

        mPointer2 = event.getPointerId(index);

        }

      }

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

    private void prepareUp2(MotionEvent event)

      {

      int index = event.getActionIndex();

      }

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

        mIsAutomatic = false;

        mLastCubitColor = -1;

        mCurrRotSpeed   = 0.0f;

        mLastX = new float[NUM_SPEED_PROBES];

        mFirstIndex =0;

        mRenderer  = new RubikRenderer(this);

        RubikActivity act = (RubikActivity)context;

        try

          {

          int esVersion = configurationInfo.reqGlEsVersion>>16;

          setRenderer(mRenderer);

        catch(Exception ex)

          act.OpenGLError();

          crashlytics.setCustomKey("GL version"    , version );

          crashlytics.setCustomKey("GL Vendor "    , vendor  );

          crashlytics.setCustomKey("GLSL renderer" , renderer);

          crashlytics.recordException(ex);

        }

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

    public void prepareDown()

      {

      mIsAutomatic = true;

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