TwistyPuzzleLib

        case TC_TETRAHEDRON    : mTouchControl = new TouchControlTetrahedron(this);

                                 break;

        case TC_HEXAHEDRON     : mTouchControl = new TouchControlHexahedron(this);

                                 break;

        case TC_OCTAHEDRON     : mTouchControl = new TouchControlOctahedron(this);

                                 break;

        case TC_DODECAHEDRON   : mTouchControl = new TouchControlDodecahedron(this);

                                 break;

        case TC_CUBOID         : int[] numLayers = getNumLayers();

                                 mTouchControl = new TouchControlCuboids(this,getDist3D(numLayers));

                                 break;

        case TC_CHANGING_MIRROR: mTouchControl = new TouchControlMirror(this);

                                 break;

        case TC_CHANGING_SQUARE: mTouchControl = new TouchControlSquare(this);

                                 break;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_CHANGING_MIRROR;

    return TC_CHANGING_MIRROR;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_CHANGING_SQUARE;

    return TC_CHANGING_SQUARE;

  public static final int TC_HEXAHEDRON      =   6;

  public static final int TC_TETRAHEDRON     =   4;

  public static final int TC_OCTAHEDRON      =   8;

  public static final int TC_DODECAHEDRON    =  12;

  public static final int TC_CUBOID          =   0;

  public static final int TC_CHANGING_MIRROR = 100;

  public static final int TC_CHANGING_SQUARE = 101;

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

// Convert the 3D point3D into a 2D point on the same face surface, but in a different

// coordinate system: a in-plane 2D coord where the origin is in the point where the axis intersects

// the surface, and whose Y axis points 'north' i.e. is in the plane given by the 3D origin, the

// original 3D Y axis and our 2D in-plane origin.

// If those 3 points constitute a degenerate triangle which does not define a plane - which can only

// happen if axis is vertical (or in theory when 2D origin and 3D origin meet, but that would have to

// mean that the distance between the center of the Object and its faces is 0) - then we arbitrarily

// decide that 2D Y = (0,0,-1) in the North Pole and (0,0,1) in the South Pole)

// (ax,ay,az) - vector normal to the face surface.

  void convertTo2Dcoords(float[] point3D, float ax, float ay, float az , float[] output)

    {

    float y0,y1,y2; // base Y vector of the 2D coord system

    if( ax==0.0f && az==0.0f )

      {

      y0=0; y1=0; y2=-ay;

      }

    else if( ay==0.0f )

      {

      y0=0; y1=1; y2=0;

      }

    else

      {

      float norm = (float)(-ay/Math.sqrt(1-ay*ay));

      y0 = norm*ax; y1= norm*(ay-1/ay); y2=norm*az;

      }

    float x0 = y1*az - y2*ay;  //

    float x1 = y2*ax - y0*az;  // (2D coord baseY) x (axis) = 2D coord baseX

    float x2 = y0*ay - y1*ax;  //

    float originAlpha = point3D[0]*ax + point3D[1]*ay + point3D[2]*az;

    float origin0 = originAlpha*ax; // coords of the point where axis

    float origin1 = originAlpha*ay; // intersects surface plane i.e.

    float origin2 = originAlpha*az; // the origin of our 2D coord system

    float v0 = point3D[0] - origin0;

    float v1 = point3D[1] - origin1;

    float v2 = point3D[2] - origin2;

    output[0] = v0*x0 + v1*x1 + v2*x2;

    output[1] = v0*y0 + v1*y1 + v2*y2;

    }

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

// find the casted axis with which our move2D vector forms an angle closest to 90 deg.

  int computeRotationIndex(float[][] rotAxis, float[] move2D, int[] enabled)

    {

    float cosAngle, minCosAngle = Float.MAX_VALUE;

    int minIndex=0, index;

    float m0 = move2D[0];

    float m1 = move2D[1];

    int numAxis = enabled[0];

    for(int axis=1; axis<=numAxis; axis++)

      {

      index = enabled[axis];

      cosAngle = m0*rotAxis[index][0] + m1*rotAxis[index][1];

      if( cosAngle<0 ) cosAngle = -cosAngle;

      if( cosAngle<minCosAngle )

        {

        minCosAngle=cosAngle;

        minIndex = index;

        }

      }

    return minIndex;

    }

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

// Copyright 2021 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.objectlib.touchcontrol;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.TwistyObject;

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

public class TouchControlMirror extends TouchControlShapeChanging

  {

  public TouchControlMirror(TwistyObject object)

    {

    super(object);

    }

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

// We want to avoid the situation when we grab by one of the inside, black faces and that makes us

// compute an incorrect 'disabled' ax.

// If the touched face is black, return one of the 'not black' faces of the current touched cubit

// - the one which is the most flat with the screen, i.e. the one whose normal makes the smallest

// angle with the camera vector.

  private int correctTouchedFace(int cubit, int face, float[] quat)

    {

    int[] numLayers = mObject.getNumLayers();

    int variant = mObject.getCubitVariant(cubit,numLayers);

    int color = mObject.getVariantFaceColor(variant,face,numLayers);

    if( color>=0 ) return face;

    float cx = mCamera[0];

    float cy = mCamera[1];

    float cz = mCamera[2];

    float len = (float)Math.sqrt(cx*cx+cy*cy+cz*cz);

    cx /= len;

    cy /= len;

    cz /= len;

    float[] normal = mInfos[mTouchedCubit][face].getNormal();

    QuatHelper.rotateVectorByQuat(mTmp,normal,quat);

    int maxFace= 0;

    float maxAngle = -1.0f;

    for(int i=0; i<6; i++)

      if( i!=face )

        {

        color = mObject.getVariantFaceColor(variant,i,numLayers);

        if( color>=0 )

          {

          normal = mInfos[mTouchedCubit][i].getNormal();

          QuatHelper.rotateVectorByQuat(mTmp,normal,quat);

          float angle = cx*mTmp[0] + cy*mTmp[1] + cz*mTmp[2];

          if( angle>maxAngle )

            {

            maxAngle= angle;

            maxFace = i;

            }

          }

        }

    return maxFace;

    }

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

  private int computeDisabledAxis()

    {

    int quatIndex  = mObject.getCubitQuatIndex(mTouchedCubit);

    float[] quat   = mQuats[quatIndex];

    int face = correctTouchedFace(mTouchedCubit,mTouchedFace,quat);

    float[] normal = mInfos[mTouchedCubit][face].getNormal();

    QuatHelper.rotateVectorByQuat(mTmp,normal,quat);

    float cx = mTmp[0];

    float cy = mTmp[1];

    float cz = mTmp[2];

    float max = -1.0f;

    int maxAxis = -1;

    for(int axis=0; axis<mNumAxis; axis++)

      {

      float ax = mRotAxis[axis].get0();

      float ay = mRotAxis[axis].get1();

      float az = mRotAxis[axis].get2();

      float angle = ax*cx + ay*cy + az*cz;

      if( angle<0 ) angle = -angle;

      if( angle>max )

        {

        max=angle;

        maxAxis = axis;

        }

      }

    return maxAxis;

    }

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

  private int computeRotationIndex(int disabled, float dx, float dy, float dz)

    {

    float min = Float.MAX_VALUE;

    int minAxis = -1;

    for(int axis=0; axis<mNumAxis; axis++)

      if( axis!=disabled )

        {

        float ax = mRotAxis[axis].get0();

        float ay = mRotAxis[axis].get1();

        float az = mRotAxis[axis].get2();

        float angle = dx*ax + dy*ay + dz*az;

        if( angle<0 ) angle=-angle;

        if( angle<min )

          {

          min=angle;

          minAxis = axis;

          }

        }

    return minAxis;

    }

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

// PUBLIC API

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

  public void newRotation(int[] output, Static4D rotatedTouchPoint)

    {

    float dx = mPoint[0] - rotatedTouchPoint.get0()/mObjectRatio;

    float dy = mPoint[1] - rotatedTouchPoint.get1()/mObjectRatio;

    float dz = mPoint[2] - rotatedTouchPoint.get2()/mObjectRatio;

    int disabledAxis = computeDisabledAxis();

    int rotIndex     = computeRotationIndex(disabledAxis,dx,dy,dz);

    int row          = computeRow(mTouchedCubit,rotIndex);

    output[0] = rotIndex;

    output[1] = row;

    }

  }

  static final float[] mTmp = new float[4];

  static class FaceInfo

    private final float[] normal;      // vector normal to the surface of the face, pointing outside.

    private final float distance;      // distance from (0,0,0) to the surface of the face

    private final float[][] vertices;  // vertices of the face. Already rotated by the initQuat and

                                       // moved by 'position' (arithmetic average of all positions)

    private final float[][] rotated;   // temp array to store vertices times rotation quaternion.

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

      distance = vx*vertices[0][0] + vy*vertices[0][1] + vz*vertices[0][2];

      normal = new float[4];

      normal[0] = vx;

      normal[1] = vy;

      normal[2] = vz;

      normal[3] = 0.0f;

      }

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

    public float[] getNormal()

      {

      return normal;

  private final float[] mTouch;

  private final Static4D mTmpAxis;

  final float[] mCamera, mPoint;

  final Static3D[] mRotAxis;

  final TwistyObject mObject;

  int mTouchedCubit, mTouchedFace, mNumAxis;

  FaceInfo[][] mInfos;

  float[][] mQuats;

  void castTouchPointOntoFace(float nx, float ny, float nz, float distance, float[] output)

  private boolean cubitFaceIsVisible(float nx, float ny, float nz, float distance)

// 5) if yes, return the distance form this point to the camera; otherwise, return NOT_TOUCHED

    QuatHelper.rotateVectorByQuat(mTmp,info.normal,quat);

    if( cubitFaceIsVisible(nx,ny,nz,info.distance) )

  int computeRow(int cubit, int rotIndex)

// really implemented in derived classes; here present only because we need to be able to

// instantiate an object of this class for MODE_REPLACE.

        float ax = mFaceAxis[face].get0();

        float ay = mFaceAxis[face].get1();

        float az = mFaceAxis[face].get2();

        convertTo2Dcoords( mPoint, ax,ay,az, mCastedRotAxis[face][casted]);

        float f = mPoint[0]*ax + mPoint[1]*ay + mPoint[2]*az;

        mCastedRotAxis4D[face][casted] = new Static4D( mPoint[0]-f*ax, mPoint[1]-f*ay, mPoint[2]-f*az, 0);

        float ax = mFaceAxis[mLastTouchedFace].get0();

        float ay = mFaceAxis[mLastTouchedFace].get1();

        float az = mFaceAxis[mLastTouchedFace].get2();

        convertTo2Dcoords(mTouch, ax,ay,az, mPoint2D);

    float ax = mFaceAxis[mLastTouchedFace].get0();

    float ay = mFaceAxis[mLastTouchedFace].get1();

    float az = mFaceAxis[mLastTouchedFace].get2();

    convertTo2Dcoords(mTouch, ax,ay,az, mMove2D);

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

// Copyright 2021 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.objectlib.touchcontrol;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.TwistyObject;

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

public class TouchControlSquare extends TouchControlShapeChanging

  {

  private static final float NOT_TOUCHED = 100000.0f;

  private static final float DIST3D = 0.5f;

  private static final float DIST2D = 0.5f;

  private static final float[][] mCastedRotAxis = { {0,1,0,0}, {1,0,0,0} };

  private static final int[] mEnabled = {2,0,1};

  private final int mNumFaces;

  private final Static3D[] mFaceAxis;

  private final float[][] mTmp4;

  private final float[][] mTmp2;

  private final float[] mTmp2D, mMove2D;

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

  public TouchControlSquare(TwistyObject object)

    {

    super(object);

    mNumFaces = object.getNumFaces();

    mFaceAxis = TouchControlHexahedron.FACE_AXIS;

    mTmp4  = new float[mNumFaces][4];

    mTmp2  = new float[mNumFaces][2];

    mTmp2D = new float[2];

    mMove2D= new float[2];

    }

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

  private boolean faceIsVisible(int index)

    {

    Static3D faceAxis = mFaceAxis[index];

    float castCameraOnAxis = mCamera[0]*faceAxis.get0() + mCamera[1]*faceAxis.get1() + mCamera[2]*faceAxis.get2();

    return castCameraOnAxis > DIST3D;

    }

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

  private boolean isInsideFace(float[] p)

    {

    return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D );

    }

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

  private int figureOutTouchedFace()

    {

    for( int face=0; face<mNumFaces; face++)

      {

      if( faceIsVisible(face) )

        {

        float nx = mFaceAxis[face].get0();

        float ny = mFaceAxis[face].get1();

        float nz = mFaceAxis[face].get2();

        castTouchPointOntoFace(nx,ny,nz, DIST3D, mTmp4[face]);

        convertTo2Dcoords(mTmp4[face], nx,ny,nz, mTmp2[face]);

        if( isInsideFace(mTmp2[face]) ) return face;

        }

      else mTmp4[face][0] = NOT_TOUCHED;

      }

    float maxDist = 0.0f;

    int faceTouched=-1;

    for( int face=0; face<mNumFaces; face++)

      {

      float[] point = mTmp4[face];

      if( point[0] != NOT_TOUCHED )

        {

        float cx = point[0]-mCamera[0];

        float cy = point[1]-mCamera[1];

        float cz = point[2]-mCamera[2];

        float dist = cx*cx + cy*cy + cz*cz;

        if( dist>maxDist )

          {

          maxDist = dist;

          faceTouched = face;

          }

        }

      }

    return faceTouched;

    }

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

// PUBLIC API

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

  public void newRotation(int[] output, Static4D rotatedTouchPoint)

    {

    int rotIndex,face = figureOutTouchedFace();

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

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

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

    float nx = mFaceAxis[face].get0();

    float ny = mFaceAxis[face].get1();

    float nz = mFaceAxis[face].get2();

    castTouchPointOntoFace(nx,ny,nz, DIST3D, mTmp);

    convertTo2Dcoords(mTmp, nx,ny,nz, mTmp2D);

    switch(face)

      {

      case 0: case 1: rotIndex = 0;

                      break;

      case 2: case 3: rotIndex = 1;

                      break;

      default       : mMove2D[0] = mTmp2D[0]-mTmp2[face][0]; // mTmp2D contains an in-face-plane 2D 'new' point of touch;

                      mMove2D[1] = mTmp2D[1]-mTmp2[face][1]; // mTmp2 contains such 'old' point. Old as in - at the time

                                                             // of touchdown; 'new' as in - now, after moving the minimal

                                                             // distance.

                      rotIndex = computeRotationIndex( mCastedRotAxis, mMove2D, mEnabled);

      }

    output[0] = rotIndex;

    if( rotIndex==0 ) output[1] = mTmp2D[1]<0 ? 0:2;

    else              output[1] = computeRow(mTouchedCubit,rotIndex);

    android.util.Log.e("D", "face touched="+face+" rotIndex="+rotIndex+" row="+output[1]+" in-plane Y="+mTmp2D[1]);

    }

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

  public void getCastedRotAxis(float[] output, Static4D quat, int rotIndex)

    {

    float[] axis = mCastedRotAxis[rotIndex];

    Static4D result = QuatHelper.rotateVectorByQuat(axis[0],axis[1],axis[2],axis[3],quat);

    float cx =result.get0();

    float cy =result.get1();

    float len = (float)Math.sqrt(cx*cx+cy*cy);

    if( len!=0 )

      {

      output[0] = cx/len;

      output[1] = cy/len;

      }

    else

      {

      output[0] = 1;

      output[1] = 0;

      }

    }

  }