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, mLastTouchedAxis, mLastTouchedLR;

    private int mNumAxis, mNumFacesPerAxis;

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

    private boolean isVertical(float x, float y)

      {

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

      }

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

    private int retFaceRotationSign(int axis, int lr)

      {

      int face = axis*mNumFacesPerAxis + lr;

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

      }

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

    private int retFaceXaxis(int axis)

      {

      return axis==0 ? VECTZ : VECTX;

      }

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

    private int retFaceYaxis(int axis)

      {

      return axis==1 ? VECTZ : VECTY;

      }

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

    private boolean faceIsVisible(int axis, int lr)

      {

      return (lr==0 ? -1:1)*mCamera[axis] > 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 axis, int lr, float[] output)

      {

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

      float ratio =  diff!=0.0f ? ( (lr-0.5f)-mCamera[axis])/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];

      mNumAxis = RubikCube.AXIS.length;

      mNumFacesPerAxis = RubikCube.FACE_COLORS.length / mNumAxis;

      }

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

// 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( mLastTouchedAxis=0; mLastTouchedAxis<mNumAxis; mLastTouchedAxis++)

        {

        for( mLastTouchedLR=0; mLastTouchedLR<mNumFacesPerAxis; mLastTouchedLR++)

          {

          if( faceIsVisible(mLastTouchedAxis, mLastTouchedLR) )

            {

            castTouchPointOntoFace(mLastTouchedAxis, mLastTouchedLR, 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(mLastTouchedAxis, mLastTouchedLR, mDiff);

      mDiff[0] -= mTouch[0];

      mDiff[1] -= mTouch[1];

      mDiff[2] -= mTouch[2];

      int xAxis = retFaceXaxis(mLastTouchedAxis);

      int yAxis = retFaceYaxis(mLastTouchedAxis);

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

      int yAxis= retFaceYaxis(mLastTouchedAxis);

      int sign = retFaceRotationSign(mLastTouchedAxis, mLastTouchedLR);

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

      return sign*angle*0.5f;

      }

}