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 TouchControlShapemod extends TouchControlShapeChanging

  {

  public TouchControlShapemod(TwistyObject object)

    {

    super(object);

    }

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

  private int computeDisabledAxis(Static4D quat)

    {

    final float D = 0.2f;

    float minLen  = 1.0f;

    float sumLens = 0.0f;

    int minIndex = -1;

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

      {

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

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

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

      float w = 0.0f;

      QuatHelper.rotateVectorByQuat(mTmp,x,y,z,w,quat);

      float rx = mTmp[0];

      float ry = mTmp[1];

      float rz = mTmp[2];

      float len = rx*rx + ry*ry;

      sumLens += len;

      if( len<minLen )

        {

        minLen = len;

        minIndex = axis;

        }

      }

    return ( minLen < D*sumLens ) ? minIndex : -1;

    }

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

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

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

    int row          = computeRow(mTouchedCubit,rotIndex);

    output[0] = rotIndex;

    output[1] = row;

    }

  }