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;

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

    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 VECTY  = 1;  // don't change this

    private static final int VECTZ  = 2;  //

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

    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

    private int retFaceXaxis(int face)

      {

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

    private int retFaceYaxis(int face)

      {

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

      switch(face)

        {

        case FRONT :

      return -1;

      }

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

      int sign = retFaceSign(face);

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

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

      int sign = retFaceSign(face);

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

      }

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

      mCamera= new float[3];

      mDiff  = new float[3];

// PUBLIC API

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

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

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

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

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

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

        }

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

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

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

      mDiff[1] -= mTouch[1];

      mDiff[2] -= mTouch[2];

      int yAxis = retFaceYaxis(mLastTouchedFace);

      float offset= mTouch[mRotationVect]+0.5f;

      mTouch[1] = mPoint[1];

      mTouch[2] = mPoint[2];

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

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

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

      int yAxis= retFaceYaxis(mLastTouchedFace);

      int sign = retFaceRotationSign(mLastTouchedFace);

}