Magic Cube

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

// Copyright 2020 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.object;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static4D;

import org.distorted.magic.RubikRenderer;

import org.distorted.magic.RubikSurfaceView;

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

public class RubikCubeMovement

{

    private final static int NONE   =-1;

    private final static int FRONT  = 0;  // has to be 6 consecutive ints

    private final static int BACK   = 1;  // FRONT ... BOTTOM

    private final static int LEFT   = 2;  //

    private final static int RIGHT  = 3;  //

    private final static int TOP    = 4;  //

    private final static int BOTTOM = 5;  //

    private static final int[] VECT = {RubikCube.VECTX,RubikCube.VECTY,RubikCube.VECTZ};

    private float[] mPoint, mCamera, mTouchPointCastOntoFace, mDiff, mTouchPoint;

    private int mRotationVect, mLastTouchedFace;

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

    private boolean isVertical(float x, float y)

      {

      return (y>x) ? (y>=-x) : (y< -x);

      }

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

    private int retFaceSign(int face)

      {

      return (face==FRONT || face==RIGHT || face==TOP) ? 1:-1;

      }

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

    private int retFaceRotationSign(int face)

      {

      return (face==BACK || face==RIGHT || face==TOP) ? 1:-1;

      }

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

// retFace{X,Y,Z}axis: 3 functions which return which real AXIS gets mapped to which when we look

// directly at a given face. For example, when we look at the RIGHT face of the cube (with TOP still

// in the top) then the 'real' X axis becomes the 'Z' axis, thus retFaceZaxis(RIGHT) = VECTX.

    private int retFaceXaxis(int face)

      {

      switch(face)

        {

        case FRONT :

        case BACK  : return RubikCube.VECTX;

        case LEFT  :

        case RIGHT : return RubikCube.VECTZ;

        case TOP   :

        case BOTTOM: return RubikCube.VECTX;

        }

      return -1;

      }

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

    private int retFaceYaxis(int face)

      {

      switch(face)

        {

        case FRONT :

        case BACK  : return RubikCube.VECTY;

        case LEFT  :

        case RIGHT : return RubikCube.VECTY;

        case TOP   :

        case BOTTOM: return RubikCube.VECTZ;

        }

      return -1;

      }

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

    private int retFaceZaxis(int face)

      {

      switch(face)

        {

        case FRONT :

        case BACK  : return RubikCube.VECTZ;

        case LEFT  :

        case RIGHT : return RubikCube.VECTX;

        case TOP   :

        case BOTTOM: return RubikCube.VECTY;

        }

      return -1;

      }

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

    private boolean faceIsVisible(int face, float cubeHalfSize)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceZaxis(face);

      return sign*mCamera[zAxis] > cubeHalfSize;

      }

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

    private void convertTouchPointToScreenSpace(Static4D accumulated, float x, float y)

      {

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

      Static4D rotatedTouchPoint= RubikSurfaceView.rotateVectorByInvertedQuat(touchPoint, accumulated);

      mPoint[0] = rotatedTouchPoint.get1();

      mPoint[1] = rotatedTouchPoint.get2();

      mPoint[2] = rotatedTouchPoint.get3();

      }

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

    private void convertCameraPointToScreenSpace(Static4D accumulated)

      {

      Static4D cameraPoint = new Static4D(0, 0, RubikRenderer.CAMERA_DISTANCE, 0);

      Static4D rotatedCamera= RubikSurfaceView.rotateVectorByInvertedQuat(cameraPoint, accumulated);

      mCamera[0] = rotatedCamera.get1();

      mCamera[1] = rotatedCamera.get2();

      mCamera[2] = rotatedCamera.get3();

      }

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

// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace,

// cast this touch point onto the surface defined by the 'face' and write the cast coords to 'output'.

// Center of the 'face' = (0,0), third coord always +- cubeHalfSize.

    private void castTouchPointOntoFace(int face, float cubeHalfSize, float[] output)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceZaxis(face);

      float diff = mPoint[zAxis]-mCamera[zAxis];

      float ratio =  diff!=0.0f ? (sign*cubeHalfSize-mCamera[zAxis])/diff : 0.0f;

      output[0] = (mPoint[0]-mCamera[0])*ratio + mCamera[0];

      output[1] = (mPoint[1]-mCamera[1])*ratio + mCamera[1];

      output[2] = (mPoint[2]-mCamera[2])*ratio + mCamera[2];

      }

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

// PUBLIC API

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

    public RubikCubeMovement()

      {

      mRotationVect = VECT[0];

      mPoint = new float[3];

      mCamera= new float[3];

      mDiff  = new float[3];

      mTouchPoint = new float[3];

      mTouchPointCastOntoFace = new float[3];

      }

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

    public boolean faceTouched(Static4D rotQuaternion, float x, float y)

      {

      float cubeHalfSize= RubikCube.CUBE_SCREEN_RATIO*0.5f;

      convertTouchPointToScreenSpace(rotQuaternion,x,y);

      convertCameraPointToScreenSpace(rotQuaternion);

      for( mLastTouchedFace=FRONT; mLastTouchedFace<=BOTTOM; mLastTouchedFace++)

        {

        if( faceIsVisible(mLastTouchedFace,cubeHalfSize) )

          {

          castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize, mTouchPointCastOntoFace);

          float qX= (mTouchPointCastOntoFace[0]+cubeHalfSize) / (2*cubeHalfSize);

          float qY= (mTouchPointCastOntoFace[1]+cubeHalfSize) / (2*cubeHalfSize);

          float qZ= (mTouchPointCastOntoFace[2]+cubeHalfSize) / (2*cubeHalfSize);

          if( qX<=1 && qX>=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return true;

          }

        }

      mLastTouchedFace = NONE;

      return false;

      }

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

    public Static2D newRotation(Static4D rotQuaternion, float x, float y)

      {

      float cubeHalfSize= RubikCube.CUBE_SCREEN_RATIO*0.5f;

      convertTouchPointToScreenSpace(rotQuaternion,x,y);

      castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff);

      mDiff[0] -= mTouchPointCastOntoFace[0];

      mDiff[1] -= mTouchPointCastOntoFace[1];

      mDiff[2] -= mTouchPointCastOntoFace[2];

      int xAxis = retFaceXaxis(mLastTouchedFace);

      int yAxis = retFaceYaxis(mLastTouchedFace);

      mRotationVect = (isVertical( mDiff[xAxis], mDiff[yAxis]) ? VECT[xAxis]:VECT[yAxis]);

      float offset= (mTouchPointCastOntoFace[mRotationVect]+cubeHalfSize)/(2*cubeHalfSize);

      mTouchPoint[0] = mPoint[0];

      mTouchPoint[1] = mPoint[1];

      mTouchPoint[2] = mPoint[2];

      return new Static2D(mRotationVect,offset);

      }

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

    public float continueRotation(Static4D rotQuaternion, float x, float y)

      {

      convertTouchPointToScreenSpace(rotQuaternion,x,y);

      mDiff[0] = mPoint[0]-mTouchPoint[0];

      mDiff[1] = mPoint[1]-mTouchPoint[1];

      mDiff[2] = mPoint[2]-mTouchPoint[2];

      int xAxis= retFaceXaxis(mLastTouchedFace);

      int yAxis= retFaceYaxis(mLastTouchedFace);

      int sign = retFaceRotationSign(mLastTouchedFace);

      float angle = (mRotationVect==xAxis ? mDiff[yAxis] : -mDiff[xAxis]);

      return sign*angle;

      }

}