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

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

package org.distorted.objects;

import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

public abstract class RubikObject extends DistortedNode

  {

  public static final int NODE_FBO_SIZE = 600;

  private static final int TEXTURE_HEIGHT = 128;

  final float[] LEGAL_QUATS;

  final Static3D[] ROTATION_AXIS;

  static float OBJECT_SCREEN_RATIO;

  private final int NUM_CUBITS;

  private int mRotRowBitmap;

  private int mRotAxis;

  private Static3D[] mOrigPos;

  private Static3D mNodeScale;

  private Static4D mQuatAccumulated;

  private Cubit[] mCubits;

  private int mSize;

  private RubikObjectList mList;

  float mStart, mStep;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  DistortedTexture mTexture;

  VertexEffectSink mSinkEffect;

  MatrixEffectScale mScaleEffect;

  MatrixEffectQuaternion mQuatCEffect;

  MatrixEffectQuaternion mQuatAEffect;

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

  RubikObject(int size, int fov, Static4D quatCur, Static4D quatAcc, DistortedTexture nodeTexture,

              MeshRectangles nodeMesh, DistortedEffects nodeEffects, int[][] moves, RubikObjectList list)

    {

    super(nodeTexture,nodeEffects,nodeMesh);

    resizeFBO(NODE_FBO_SIZE, NODE_FBO_SIZE);

    mList = list;

    mOrigPos = getCubitPositions(size);

    LEGAL_QUATS = getLegalQuats();

    NUM_CUBITS  = mOrigPos.length;

    ROTATION_AXIS = getRotationAxis();

    OBJECT_SCREEN_RATIO = getScreenRatio();

    mSize = size;

    computeStartAndStep(mOrigPos);

    mNodeScale= new Static3D(1,1,1);

    mQuatAccumulated = quatAcc;

    mSinkEffect  = getSink(mSize);

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    Static3D center = new Static3D(0,0,0);

    float scale = OBJECT_SCREEN_RATIO*NODE_FBO_SIZE/mSize;

    mScaleEffect = new MatrixEffectScale(new Static3D(scale,scale,scale));

    mQuatCEffect = new MatrixEffectQuaternion(quatCur, center);

    mQuatAEffect = new MatrixEffectQuaternion(quatAcc, center);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    nodeEffects.apply(nodeScaleEffect);

    mCubits = new Cubit[NUM_CUBITS];

    mTexture = new DistortedTexture();

    int vertices = (int)(24.0f/mSize + 2.0f);

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

      {

      MeshBase cubitMesh = createCubitMesh(i,vertices);

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

      textureCubitMesh(cubitMesh,i);

      attach(mCubits[i].mNode);

      }

    setupPosition(moves);

    setProjection(fov, 0.1f);

    }

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

  private void textureCubitMesh(MeshBase mesh, int cubit)

    {

    boolean belongs;

    final int numFaces = getNumFaces();

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

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

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

      {

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

        {

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

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

        }

      }

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

      {

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

        {

        belongs = isOnFace(cubit, i, 0 );

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

        }

      }

    mesh.setTextureMap(maps);

    }

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

// Cast centers of all Cubits on the first rotation Axis and compute the leftmost and rightmost

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

    }

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

  private boolean belongsToRotation( int cubit, int axis, int rowBitmap)

    {

    int cubitRow = (int)(mCubits[cubit].mRotationRow[axis]+0.5f);

    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;

    }

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

// note the minus in front of the sin() - we rotate counterclockwise

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

  private Static4D makeQuaternion(int axisIndex, int angleInDegrees)

    {

    Static3D axis = ROTATION_AXIS[axisIndex];

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

    }

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

  private void setupPosition(int[][] moves)

    {

    if( moves!=null )

      {

      Static4D quat;

      int axis, rowBitmap, angle;

      int corr = (360/getBasicAngle());

      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) )

            {

            mCubits[j].removeRotationNow(quat);

            }

        }

      }

    }

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

  int getCubitFaceColorIndex(int cubit, int face)

    {

    return mCubits[cubit].getColorIndex(face);

    }

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

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

    final int numColors = getNumFaces();

    Paint paint = new Paint();

    bitmap = Bitmap.createBitmap( (numColors+1)*TEXTURE_HEIGHT, TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmap);

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

    paint.setColor(0xff000000);

    canvas.drawRect(0, 0, (numColors+1)*TEXTURE_HEIGHT, TEXTURE_HEIGHT, paint);

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

      {

      createFaceTexture(canvas, paint, i, i*TEXTURE_HEIGHT, 0, TEXTURE_HEIGHT);

      }

    mTexture.setTexture(bitmap);

    }

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

  public int getSize()

    {

    return mSize;

    }

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

  public void continueRotation(float angleInDegrees)

    {

    mRotationAngleStatic.set0(angleInDegrees);

    }

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

  public Static4D getRotationQuat()

      {

      return mQuatAccumulated;

      }

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

  public void recomputeScaleFactor(int scrWidth, int scrHeight)

    {

    float factor = Math.min(scrWidth,scrHeight);

    mNodeScale.set(factor,factor,factor);

    }

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

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

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].restorePreferences(preferences);

    }

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

  public void releaseResources()

    {

    mTexture.markForDeletion();

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

    }

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

  public void apply(Effect effect, int position)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].mEffect.apply(effect, position);

    }

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

  public void remove(long effectID)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].mEffect.abortById(effectID);

    }

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

  public void solve()

    {

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

    }

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

  public boolean isSolved()

    {

    Static4D q = mCubits[0].mQuatScramble;

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

      {

      if( !mCubits[i].thereIsNoVisibleDifference(q) ) return false;

      }

    return true;

    }

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

  public void resetAllTextureMaps()

    {

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

      {

      textureCubitMesh( mCubits[i].getMesh() , i );

      }

    }

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

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

    {

    final int numFaces = getNumFaces();

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

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

    maps[face] = new Static4D( newColor*ratio, 0.0f, ratio, 1.0f);

    mCubits[cubit].getMesh().setTextureMap(maps);

    }

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

  public void beginNewRotation(int axis, int row )

    {

    if( axis<0 || axis>=ROTATION_AXIS.length )

      {

      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;

      }

    mRotAxis       = axis;

    mRotRowBitmap  = (1<<row);

    mRotationAngleStatic.set0(0.0f);

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

      if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

        {

        mCubits[i].beginNewRotation(axis);

        }

     }

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

  public long addNewRotation( int axis, int rowBitmap, int angle, long durationMillis, EffectListener listener )

     {

     long effectID=0;

     int firstCubit = -1;

     mRotAxis       = axis;

     mRotRowBitmap  = rowBitmap;

     mRotationAngleStatic.set0(0.0f);

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

       if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

         {

         mCubits[i].addNewRotation(axis,durationMillis,angle);

         if( firstCubit<0 ) firstCubit = i;

         }

     if( firstCubit>=0 ) effectID = mCubits[firstCubit].setUpCallback(listener);

     return effectID;

     }

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

  public long finishRotationNow(EffectListener listener)

    {

    int firstCubit= -1;

    long effectID =  0;

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

      {

      if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

        {

        if( firstCubit<0 )

          {

          firstCubit=i;

          float angle = mRotationAngleStatic.get0();

          int nearestAngleInDegrees = computeNearestAngle(angle);

          mRotationAngleStatic.set0(angle);

          mRotationAngleFinal.set0(nearestAngleInDegrees);

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

          }

        mCubits[i].resetRotationAngle();

        }

      }

    if( firstCubit>=0 ) effectID = mCubits[firstCubit].setUpCallback(listener);

    return effectID;

    }

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

  public void removeRotationNow()

     {

     boolean first = true;

     Static4D quat = null;

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

       if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

         {

         if( first )

           {

           first = false;

           float angle = mRotationAngleFinal.get0();

           int nearestAngleInDegrees = computeNearestAngle(angle);

           double nearestAngleInRadians = nearestAngleInDegrees*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();

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

           }

         mCubits[i].removeRotationNow(quat);

         }

     mRotationAngleStatic.set0(0);

     }

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

  public void initializeObject(int[][] moves)

    {

    solve();

    setupPosition(moves);

    }

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

  public int getCubit(float[] point3D)

    {

    float dist, minDist = Float. MAX_VALUE;

    int currentBest=-1;

    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;

    }

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

  public int computeNearestAngle(float angle)

    {

    final int NEAREST = 360/getBasicAngle();

    int tmp = (int)((angle+NEAREST/2)/NEAREST);

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

    return NEAREST*tmp;

    }

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

  public RubikObjectList getObjectList()

    {

    return mList;

    }

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

  abstract float getScreenRatio();

  abstract VertexEffectSink getSink(int size);

  abstract Static3D[] getCubitPositions(int size);

  abstract float[] getLegalQuats();

  abstract int getNumFaces();

  abstract MeshBase createCubitMesh(int cubit, int vertices);

  abstract void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top, int side);

  public abstract Static3D[] getRotationAxis();

  public abstract int getBasicAngle();

  public abstract float returnMultiplier();

  public abstract float returnRotationFactor(float offset);

  public abstract String retObjectString();

  public abstract float[] getRowChances();

  }