TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.touchcontrol;

import org.distorted.library.helpers.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 stiShape    = mObject.getVariantStickerShape(variant,face);

    if( stiShape>=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 )

        {

        stiShape = mObject.getVariantStickerShape(variant,i);

        if( stiShape>=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, Static4D quat)

    {

    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;

    }

  }