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

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

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.io.IOException;

import java.io.InputStream;

  private static final float MAX_SIZE_CHANGE = 1.3f;

  private static final float MIN_SIZE_CHANGE = 0.8f;

  private DistortedEffects mEffects;

  private Dynamic1D mRotationAngle;

  private Static3D mRotationAxis;

  DistortedTexture mTexture;

  MatrixEffectScale mScaleEffect;

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

    mInitScreenRatio = mObjectScreenRatio;

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

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    mObjectScale = new Static3D(scale,scale,scale);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

      {

      mEffects.apply(vq);

      }

    attach( new DistortedNode(mTexture,mEffects,mMesh) );

  private void createMeshAndCubits(RubikObjectList list, Resources res)

    {

    mCubits = new Cubit[NUM_CUBITS];

    if( mCreateFromDMesh )

      {

      int sizeIndex = RubikObjectList.getSizeIndex(list.ordinal(),mSize);

      int resourceID= list.getResourceIDs()[sizeIndex];

      InputStream is = res.openRawResource(resourceID);

      DataInputStream dos = new DataInputStream(is);

      mMesh = new MeshFile(dos);

      try

        {

        is.close();

        }

      catch(IOException e)

        {

        android.util.Log.e("meshFile", "Error closing InputStream: "+e.toString());

        }

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

        {

        mCubits[i] = new Cubit(this,mOrigPos[i]);

        mMesh.setEffectAssociation(i, mCubits[i].computeAssociation(), 0);

        }

      }

    else

      {

      MeshBase[] cubitMesh = new MeshBase[NUM_CUBITS];

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

        {

        mCubits[i] = new Cubit(this,mOrigPos[i]);

        cubitMesh[i] = createCubitMesh(i);

        cubitMesh[i].apply(new MatrixEffectMove(mOrigPos[i]),1,0);

        cubitMesh[i].setEffectAssociation(0, mCubits[i].computeAssociation(), 0);

        }

      mMesh = new MeshJoined(cubitMesh);

      resetAllTextureMaps();

      }

    }

  public void setObjectRatio(float sizeChange)

    {

    mObjectScreenRatio *= (1.0f+sizeChange)/2;

    if( mObjectScreenRatio > MAX_SIZE_CHANGE*mInitScreenRatio)

      {

      mObjectScreenRatio = MAX_SIZE_CHANGE*mInitScreenRatio;

      }

    if( mObjectScreenRatio < MIN_SIZE_CHANGE*mInitScreenRatio)

      {

      mObjectScreenRatio = MIN_SIZE_CHANGE*mInitScreenRatio;

      }

    float scale = mObjectScreenRatio*mNodeSize/mSize;

    mObjectScale.set(scale,scale,scale);

    }

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

  static float getObjectRatio()

    {

    return mObjectScreenRatio;

    }

// one. From there compute the 'start' (i.e. the leftmost) and 'step' (i.e. distance between two

// consecutive).

// it is assumed that other rotation axis have the same 'start' and 'step' - this is the case with

// the Cube and the Pyraminx.

// Start and Step are then needed to compute which rotation row (with respect to a given axis) a

// given Cubit belongs to.

  private void computeStartAndStep(Static3D[] pos)

    {

    float min = Float.MAX_VALUE;

    float max = Float.MIN_VALUE;

    float axisX = ROTATION_AXIS[0].get0();

    float axisY = ROTATION_AXIS[0].get1();

    float axisZ = ROTATION_AXIS[0].get2();

    float tmp;

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

      {

      tmp = pos[i].get0()*axisX + pos[i].get1()*axisY + pos[i].get2()*axisZ;

      if( tmp<min ) min=tmp;

      if( tmp>max ) max=tmp;

      }

    mStart = min;

    mStep  = (max-min+1.0f)/mSize;

    }

    return ((1<<cubitRow)&rowBitmap)!=0;

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

// we cannot use belongsToRotation for deciding if to texture a face. Counterexample: the 'rotated'

// tetrahedrons of Pyraminx nearby the edge: they belong to rotation but their face which is rotated

// away from the face of the Pyraminx shouldn't be textured.

  private boolean isOnFace( int cubit, int axis, int row)

    {

    final float MAX_ERROR = 0.0001f;

    float diff = mCubits[cubit].mRotationRow[axis] - row;

    return diff*diff < MAX_ERROR;

// when looking towards the direction where the axis increases in values.

    while( angleInDegrees<0 ) angleInDegrees += 360;

    angleInDegrees %= 360;

    float cosA = (float)Math.cos(Math.PI*angleInDegrees/360);

    float sinA =-(float)Math.sqrt(1-cosA*cosA);

    return new Static4D(axis.get0()*sinA, axis.get1()*sinA, axis.get2()*sinA, cosA);

    }

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

    if( moves!=null )

      {

      Static4D quat;

      for(int[] move: moves)

        {

        axis     = move[0];

        rowBitmap= move[1];

        angle    = move[2]*corr;

        quat     = makeQuaternion(axis,angle);

        for(int j=0; j<NUM_CUBITS; j++)

          if( belongsToRotation(j,axis,rowBitmap) )

            {

            mMesh.setEffectAssociation(j,mCubits[j].computeAssociation(),index);

        }

      }

  int getCubitFaceColorIndex(int cubit, int face)

    {

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

// Clamp all rotated positions to one of those original ones to avoid accumulating errors.

  void clampPos(Static3D pos)

    {

    float currError, minError = Float.MAX_VALUE;

    int minErrorIndex= -1;

    float x = pos.get0();

    float y = pos.get1();

    float z = pos.get2();

    float xo,yo,zo;

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

      {

      xo = mOrigPos[i].get0();

      yo = mOrigPos[i].get1();

      zo = mOrigPos[i].get2();

      currError = (xo-x)*(xo-x) + (yo-y)*(yo-y) + (zo-z)*(zo-z);

      if( currError<minError )

        {

        minError = currError;

        minErrorIndex = i;

        }

      }

    pos.set( mOrigPos[minErrorIndex] );

    }

// the getFaceColors + final black in a horizontal strip.

  public void createTexture()

    {

    Bitmap bitmap;

    Paint paint = new Paint();

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

    mTexture.setTexture(bitmap);

    }

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

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

      {

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

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

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].savePreferences(editor);

    }

      {

      int index = mCubits[i].restorePreferences(preferences);

      mMesh.setEffectAssociation(i,mCubits[i].computeAssociation(),index);

      }

  public void releaseResources()

    {

    mTexture.markForDeletion();

    }

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

  public void apply(Effect effect, int position)

    {

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

  public void remove(long effectID)

    {

      {

      mCubits[i].solve();

      mMesh.setEffectAssociation(i, mCubits[i].computeAssociation(), 0);

      }

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

  public boolean isSolved()

    {

    return true;

    }

  public void resetAllTextureMaps()

    {

    final float ratio = 1.0f/(NUM_FACES+1);

    for(int cubit=0; cubit<NUM_CUBITS; cubit++)

      if( 2*ROTATION_AXIS.length == NUM_FACES )  // i.e. there are faces on both ends of the axis (cube)

        {

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

          {

          belongs = isOnFace(cubit, i/2, i%2==0 ? mSize-1:0 );

          maps[i] = new Static4D( (belongs?i:NUM_FACES)*ratio, 0.0f, ratio, 1.0f);

          }

        }

      else if( ROTATION_AXIS.length == NUM_FACES )  // just a single face on the right end of an axis (pyraminx)

        {

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

          {

          belongs = isOnFace(cubit, i, 0 );

          maps[i] = new Static4D( (belongs?i:NUM_FACES)*ratio, 0.0f, ratio, 1.0f);

          }

        }

      mMesh.setTextureMap(maps,NUM_FACES*cubit);

    }

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

  public void setTextureMap(int cubit, int face, int newColor)

    {

    final Static4D[] maps = new Static4D[NUM_FACES];

    mMesh.setTextureMap(maps,NUM_FACES*cubit);

      {

      android.util.Log.e("object", "invalid rotation axis: "+axis);

      return;

      }

    if( row<0 || row>=mSize )

      {

      android.util.Log.e("object", "invalid rotation row: "+row);

      return;

      }

    mRotRowBitmap= (1<<row);

    mRotationAngle.add(mRotationAngleStatic);

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

    mRotAxis     = axis;

    mRotRowBitmap= rowBitmap;

    mRotationAxis.set( ROTATION_AXIS[axis] );

    mRotationAngle.setDuration(durationMillis);

    mRotationAngle.resetToBeginning();

    mRotationAngle.add(new Static1D(0));

    mRotationAngle.add(new Static1D(angle));

    return mRotateEffect.getID();

    }

    float angle = getAngle();

    mRotationAngleStatic.set0(angle);

    mRotationAngleFinal.set0(nearestAngleInDegrees);

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

    mRotationAngle.setDuration(POST_ROTATION_MILLISEC);

    mRotationAngle.resetToBeginning();

    mRotationAngle.removeAll();

    mRotationAngle.add(mRotationAngleStatic);

    mRotationAngle.add(mRotationAngleMiddle);

    mRotationAngle.add(mRotationAngleFinal);

    mRotateEffect.notifyWhenFinished(listener);

    return mRotateEffect.getID();

    }

      }

    else

      {

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.log("points in RotationAngle: "+pointNum);

      return 0;

    }

    float angle = getAngle();

    double nearestAngleInRadians = angle*Math.PI/180;

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

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

    float axisX = ROTATION_AXIS[mRotAxis].get0();

    float axisY = ROTATION_AXIS[mRotAxis].get1();

    float axisZ = ROTATION_AXIS[mRotAxis].get2();

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

    mRotationAngle.removeAll();

    mRotationAngleStatic.set0(0);

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

      if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

        {

        int index = mCubits[i].removeRotationNow(quat);

        mMesh.setEffectAssociation(i,mCubits[i].computeAssociation(),index);

        }

    }

    solve();

    setupPosition(moves);

    }

  public int getCubit(float[] point3D)

    {

    float multiplier = returnMultiplier();

    point3D[0] *= multiplier;

    point3D[1] *= multiplier;

    point3D[2] *= multiplier;

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

      {

      dist = mCubits[i].getDistSquared(point3D);

      if( dist<minDist )

        {

        minDist = dist;

        currentBest = i;

        }

      }

    return currentBest;

    }

    final int NEAREST = 360/getBasicAngle();

    if( angle< -(NEAREST*0.5) ) tmp-=1;