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;

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

class RubikCubeMovement extends RubikObjectMovement

{

    private final static int LEFT   = 0;  // axisX left

    private final static int RIGHT  = 1;  // axisX right

    private final static int BOTTOM = 2;  // axisY left

    private final static int TOP    = 3;  // axisY right

    private final static int BACK   = 4;  // axisZ left

    private final static int FRONT  = 5;  // axisZ right

    private static final int VECTX  = 0;  //

    private static final int VECTY  = 1;  // don't change this

    private static final int VECTZ  = 2;  //

    private float[] mPoint, mCamera, mDiff, mTouch;

    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 retFaceXaxis(RIGHT) = VECTZ.

    private int retFaceXaxis(int face)

      {

      return face==LEFT || face==RIGHT ? VECTZ : VECTX;

      }

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

    private int retFaceYaxis(int face)

      {

      return face==TOP || face==BOTTOM ? VECTZ : VECTY;

      }

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

    private int retFaceAxis(int face)

      {

      switch(face)

        {

        case FRONT :

        case BACK  : return VECTZ;

        case LEFT  :

        case RIGHT : return VECTX;

        case TOP   :

        case BOTTOM: return VECTY;

        }

      return -1;

      }

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

    private boolean faceIsVisible(int face)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceAxis(face);

      return sign*mCamera[zAxis] > 0.5f;

      }

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

// 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[] output)

      {

      int sign = retFaceSign(face);

      int zAxis= retFaceAxis(face);

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

      float ratio =  diff!=0.0f ? (sign*0.5f-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];

      }

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

    RubikCubeMovement()

      {

      mPoint = new float[3];

      mCamera= new float[3];

      mDiff  = new float[3];

      mTouch = new float[3];

      }

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

// PUBLIC API

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

    public boolean faceTouched(Static4D rotatedTouchPoint, Static4D rotatedCamera)

      {

      mPoint[0]  = rotatedTouchPoint.get0()/RubikObject.OBJECT_SCREEN_RATIO;

      mPoint[1]  = rotatedTouchPoint.get1()/RubikObject.OBJECT_SCREEN_RATIO;

      mPoint[2]  = rotatedTouchPoint.get2()/RubikObject.OBJECT_SCREEN_RATIO;

      mCamera[0] = rotatedCamera.get0()/RubikObject.OBJECT_SCREEN_RATIO;

      mCamera[1] = rotatedCamera.get1()/RubikObject.OBJECT_SCREEN_RATIO;

      mCamera[2] = rotatedCamera.get2()/RubikObject.OBJECT_SCREEN_RATIO;

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

        {

        if( faceIsVisible(mLastTouchedFace) )

          {

          castTouchPointOntoFace(mLastTouchedFace, mTouch);

          if( mTouch[0]<=0.5f && mTouch[0]>=-0.5f &&

              mTouch[1]<=0.5f && mTouch[1]>=-0.5f &&

              mTouch[2]<=0.5f && mTouch[2]>=-0.5f  ) return true;

          }

        }

      return false;

      }

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

    public Static2D newRotation(Static4D rotatedTouchPoint)

      {

      mPoint[0] = rotatedTouchPoint.get0()/RubikObject.OBJECT_SCREEN_RATIO;

      mPoint[1] = rotatedTouchPoint.get1()/RubikObject.OBJECT_SCREEN_RATIO;

      mPoint[2] = rotatedTouchPoint.get2()/RubikObject.OBJECT_SCREEN_RATIO;

      castTouchPointOntoFace(mLastTouchedFace,mDiff);

      mDiff[0] -= mTouch[0];

      mDiff[1] -= mTouch[1];

      mDiff[2] -= mTouch[2];

      int xAxis = retFaceXaxis(mLastTouchedFace);

      int yAxis = retFaceYaxis(mLastTouchedFace);

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

      float offset= mTouch[mRotationVect]+0.5f;

      mTouch[0] = mPoint[0];

      mTouch[1] = mPoint[1];

      mTouch[2] = mPoint[2];

      return new Static2D(mRotationVect,offset);

      }

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

    public float continueRotation(Static4D rotatedTouchPoint)

      {

      mDiff[0] = rotatedTouchPoint.get0()/RubikObject.OBJECT_SCREEN_RATIO-mTouch[0];

      mDiff[1] = rotatedTouchPoint.get1()/RubikObject.OBJECT_SCREEN_RATIO-mTouch[1];

      mDiff[2] = rotatedTouchPoint.get2()/RubikObject.OBJECT_SCREEN_RATIO-mTouch[2];

      int xAxis= retFaceXaxis(mLastTouchedFace);

      int yAxis= retFaceYaxis(mLastTouchedFace);

      int sign = retFaceRotationSign(mLastTouchedFace);

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

      return sign*angle*0.5f;

      }

}