Magic Cube

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

// Copyright 2019 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.objects;

import android.content.SharedPreferences;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.main.RubikSurfaceView;

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

class Cubit

  {

  private static final Static3D matrCenter = new Static3D(0,0,0);

  private final Static3D mOrigPosition;

  private RubikObject mParent;

  private MeshBase mMesh;

  private Static3D mRotationAxis;

  private MatrixEffectRotate mRotateEffect;

  private Static3D mCurrentPosition;

  private int mNumAxis;

  Dynamic1D mRotationAngle;

  DistortedNode mNode;

  DistortedEffects mEffect;

  Static4D mQuatScramble;

  float[] mRotationRow;

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

// Because of quatMultiplication, errors can accumulate - so to avoid this, we

// correct the value of the 'scramble' quat to what it should be - one of the legal quats from the

// list LEGAL_QUATS.

//

// We also have to remember that the group of unit quaternions is a double-cover of rotations

// in 3D ( q represents the same rotation as -q ) - so invert if needed.

  private void normalizeScrambleQuat(Static4D quat)

    {

    final float MAX_ERROR = 0.0001f;

    float x = quat.get0();

    float y = quat.get1();

    float z = quat.get2();

    float w = quat.get3();

    float diff;

    for(float legal: mParent.LEGAL_QUATS)

      {

      diff = x-legal;

      if( diff*diff<MAX_ERROR ) x = legal;

      diff = y-legal;

      if( diff*diff<MAX_ERROR ) y = legal;

      diff = z-legal;

      if( diff*diff<MAX_ERROR ) z = legal;

      diff = w-legal;

      if( diff*diff<MAX_ERROR ) w = legal;

      }

    if( w<0 )

      {

      w = -w;

      z = -z;

      y = -y;

      x = -x;

      }

    else if( w==0 )

      {

      if( z<0 )

        {

        z = -z;

        y = -y;

        x = -x;

        }

      else if( z==0 )

        {

        if( y<0 )

          {

          y = -y;

          x = -x;

          }

        else if( y==0 )

          {

          if( x<0 )

            {

            x = -x;

            }

          }

        }

      }

    quat.set(x,y,z,w);

    }

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

  private void modifyCurrentPosition(Static4D quat)

    {

    float cubitCenterX = mCurrentPosition.get0();

    float cubitCenterY = mCurrentPosition.get1();

    float cubitCenterZ = mCurrentPosition.get2();

    Static4D cubitCenter =  new Static4D(cubitCenterX, cubitCenterY, cubitCenterZ, 0);

    Static4D rotatedCenter = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat);

    float rotatedX = rotatedCenter.get0();

    float rotatedY = rotatedCenter.get1();

    float rotatedZ = rotatedCenter.get2();

    mCurrentPosition.set(rotatedX, rotatedY, rotatedZ);

    mParent.clampPos(mCurrentPosition);

    computeRotationRow();

    }

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

// cast current position on axis; use mStart and mStep to compute the rotation row for each axis.

  private void computeRotationRow()

    {

    float tmp;

    Static3D axis;

    float x = mCurrentPosition.get0();

    float y = mCurrentPosition.get1();

    float z = mCurrentPosition.get2();

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

      {

      axis = mParent.ROTATION_AXIS[i];

      tmp = x*axis.get0() + y*axis.get1() + z*axis.get2();

      mRotationRow[i] = (tmp-mParent.mStart)/mParent.mStep;

      }

    }

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

  Cubit(RubikObject parent, MeshBase mesh, Static3D position)

    {

    float x = position.get0();

    float y = position.get1();

    float z = position.get2();

    Static3D vector = new Static3D(x,y,z);

    mParent          = parent;

    mMesh            = mesh;

    mOrigPosition    = new Static3D(x,y,z);

    mQuatScramble    = new Static4D(0,0,0,1);

    mRotationAngle   = new Dynamic1D();

    mRotationAxis    = new Static3D(1,0,0);

    mCurrentPosition = position;

    mRotateEffect    = new MatrixEffectRotate(mRotationAngle, mRotationAxis, matrCenter);

    mNumAxis     = mParent.ROTATION_AXIS.length;

    mRotationRow = new float[mNumAxis];

    computeRotationRow();

    mEffect = new DistortedEffects();

    mEffect.apply(mParent.mSinkEffect);

    mEffect.apply( new MatrixEffectMove(vector) );

    mEffect.apply( new MatrixEffectQuaternion(mQuatScramble, matrCenter));

    mEffect.apply(mRotateEffect);

    mEffect.apply(mParent.mQuatAEffect);

    mEffect.apply(mParent.mQuatCEffect);

    mEffect.apply(mParent.mScaleEffect);

    mNode = new DistortedNode(mParent.mTexture,mEffect,mMesh);

    }

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

  void savePreferences(SharedPreferences.Editor editor)

    {

    String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();

    editor.putFloat("qx_"+number, mQuatScramble.get0());

    editor.putFloat("qy_"+number, mQuatScramble.get1());

    editor.putFloat("qz_"+number, mQuatScramble.get2());

    editor.putFloat("qw_"+number, mQuatScramble.get3());

    }

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

  void restorePreferences(SharedPreferences preferences)

    {

    String number = mOrigPosition.get0()+"_"+mOrigPosition.get1()+"_"+mOrigPosition.get2();

    float qx = preferences.getFloat("qx_"+number, 0.0f);

    float qy = preferences.getFloat("qy_"+number, 0.0f);

    float qz = preferences.getFloat("qz_"+number, 0.0f);

    float qw = preferences.getFloat("qw_"+number, 1.0f);

    mQuatScramble.set(qx,qy,qz,qw);

    modifyCurrentPosition(mQuatScramble);

    }

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

// return if the Cubit, when rotated with its own mQuatScramble, would have looked any different

// then if it were rotated by quaternion 'quat'.

// No it is not so simple as the quats need to be the same - imagine a 4x4x4 cube where the two

// middle squares get interchanged. No visible difference!

//

// So: this is true iff the cubit

// a) is a corner or edge and the quaternions are the same

// b) is inside one of the faces and after rotations by both quats it ends up on the same face.

  boolean thereIsNoVisibleDifference(Static4D quat)

    {

    if ( mQuatScramble.get0()==quat.get0() &&

         mQuatScramble.get1()==quat.get1() &&

         mQuatScramble.get2()==quat.get2() &&

         mQuatScramble.get3()==quat.get3()  ) return true;

    int belongsToHowManyFaces = 0;

    int size = mParent.getSize()-1;

    float row;

    final float MAX_ERROR = 0.01f;

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

      {

      row = mRotationRow[i];

      if( (row     <MAX_ERROR && row     >-MAX_ERROR) ||

          (row-size<MAX_ERROR && row-size>-MAX_ERROR)  ) belongsToHowManyFaces++;

      }

    switch(belongsToHowManyFaces)

      {

      case 0 : return true ;  // 'inside' cubit that does not lie on any face

      case 1 :                // cubit that lies inside one of the faces

               float cubitCenterX = mCurrentPosition.get0();

               float cubitCenterY = mCurrentPosition.get1();

               float cubitCenterZ = mCurrentPosition.get2();

               Static4D cubitCenter = new Static4D(cubitCenterX, cubitCenterY, cubitCenterZ, 0);

               Static4D rotated1 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat);

               Static4D rotated2 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, mQuatScramble );

               float row1, row2, row3, row4;

               float ax,ay,az;

               Static3D axis;

               float x1 = rotated1.get0();

               float y1 = rotated1.get1();

               float z1 = rotated1.get2();

               float x2 = rotated2.get0();

               float y2 = rotated2.get1();

               float z2 = rotated2.get2();

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

                 {

                 axis = mParent.ROTATION_AXIS[i];

                 ax = axis.get0();

                 ay = axis.get1();

                 az = axis.get2();

                 row1 = ((x1*ax + y1*ay + z1*az) - mParent.mStart) / mParent.mStep;

                 row2 = ((x2*ax + y2*ay + z2*az) - mParent.mStart) / mParent.mStep;

                 row3 = row1 - size;

                 row4 = row2 - size;

                 if( (row1<MAX_ERROR && row1>-MAX_ERROR && row2<MAX_ERROR && row2>-MAX_ERROR) ||

                     (row3<MAX_ERROR && row3>-MAX_ERROR && row4<MAX_ERROR && row4>-MAX_ERROR)  )

                   {

                   return true;

                   }

                 }

               return false;

      default: return false;  // edge or corner

      }

    }

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

  long finishRotationNow(EffectListener listener)

    {

    int pointNum = mRotationAngle.getNumPoints();

    if( pointNum>=1 )

      {

      float startingAngle = mRotationAngle.getPoint(pointNum-1).get0();

      int nearestAngleInDegrees = mParent.computeNearestAngle(startingAngle);

      mParent.mRotationAngleStatic.set0(startingAngle);

      mParent.mRotationAngleFinal.set0(nearestAngleInDegrees);

      mParent.mRotationAngleMiddle.set0( nearestAngleInDegrees + (nearestAngleInDegrees-startingAngle)*0.2f );

      return setUpCallback(listener);

      }

    else

      {

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("points", "finish, points in RotationAngle: "+pointNum );

      return 0;

      }

    }

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

  Static4D returnRotationQuat(int axis)

    {

    int pointNum = mRotationAngle.getNumPoints();

    if( pointNum>=1 )

      {

      float axisX = mParent.ROTATION_AXIS[axis].get0();

      float axisY = mParent.ROTATION_AXIS[axis].get1();

      float axisZ = mParent.ROTATION_AXIS[axis].get2();

      float startingAngle = mRotationAngle.getPoint(pointNum-1).get0();

      int nearestAngleInDegrees = mParent.computeNearestAngle(startingAngle);

      double nearestAngleInRadians = nearestAngleInDegrees*Math.PI/180;

      float sinA =-(float)Math.sin(nearestAngleInRadians*0.5);

      float cosA = (float)Math.cos(nearestAngleInRadians*0.5);

      return new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA);

      }

    else

      {

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("points", "return, points in RotationAngle: "+pointNum );

      return null;

      }

    }

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

  void removeRotationNow(Static4D quat)

    {

    mRotationAngle.removeAll();

    mQuatScramble.set(RubikSurfaceView.quatMultiply(quat,mQuatScramble));

    normalizeScrambleQuat( mQuatScramble );

    modifyCurrentPosition(quat);

    }

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

// all DistortedTextures, DistortedNodes, DistortedFramebuffers, DistortedScreens and all types of

// Meshes HAVE TO be markedForDeletion when they are no longer needed- otherwise we have a major

// memory leak.

  void releaseResources()

    {

    mMesh.markForDeletion();

    mNode.markForDeletion();

    }

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

  void solve()

    {

    mQuatScramble.set(0,0,0,1);

    mCurrentPosition.set(mOrigPosition);

    computeRotationRow();

    }

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

  void beginNewRotation(int axis)

    {

    mRotationAxis.set( mParent.ROTATION_AXIS[axis] );

    mRotationAngle.add(mParent.mRotationAngleStatic);

    }

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

  void addNewRotation(int axis, long durationMillis, int angle)

    {

    mRotationAxis.set( mParent.ROTATION_AXIS[axis] );

    mRotationAngle.setDuration(durationMillis);

    mRotationAngle.resetToBeginning();

    mRotationAngle.add(new Static1D(0));

    mRotationAngle.add(new Static1D(angle));

    }

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

  long setUpCallback(EffectListener listener)

    {

    mRotateEffect.notifyWhenFinished(listener);

    return mRotateEffect.getID();

    }

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

  float getDistSquared(float[] point)

    {

    float dx = mCurrentPosition.get0() - point[0];

    float dy = mCurrentPosition.get1() - point[1];

    float dz = mCurrentPosition.get2() - point[2];

    return dx*dx + dy*dy + dz*dz;

    }

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

  int getColorIndex(int face)

    {

    Static4D texMap = mMesh.getTextureMap(face);

    return (int)(texMap.get0() / texMap.get2());

    }

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

  MeshBase getMesh()

    {

    return mMesh;

    }

}