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.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.type.Static3D;

import org.distorted.library.type.Static4D;

  DistortedTexture mTexture;

  VertexEffectSink mSinkEffect;

  MatrixEffectScale mScaleEffect;

  MatrixEffectQuaternion mQuatCEffect;

  MatrixEffectQuaternion mQuatAEffect;

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

              MeshRectangles nodeMesh, DistortedEffects nodeEffects, String moves, RubikObjectList list)

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

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

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

    mQuatAccumulated = quatAcc;

    mQuatAEffect = new MatrixEffectQuaternion(quatAcc, center);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    mCubits = new Cubit[NUM_CUBITS];

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

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

      {

      attach(mCubits[i].mNode);

      }

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

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

        {

        }

      }

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

        {

        }

      }

    mesh.setTextureMap(maps);

    }

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

    {

    }

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

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

    rotationAngle.setDuration(POST_ROTATION_MILLISEC);

    rotationAngle.resetToBeginning();

    rotationAngle.removeAll();

    rotationAngle.add(mRotationAngleStatic);

    rotationAngle.add(mRotationAngleMiddle);

    rotationAngle.add(mRotationAngleFinal);

    }

// TODO

	private boolean scheduleMultiRotation(int rotV, int rotRC, int rotA)

	  {

	  /*

		int index, tmp;

		if( numRotations>0 )

		  {

			if( rotVector!=rotV ) return false;

			index=0;

			tmp=rotRC;

			while( tmp!=0 )

			  {

				if( (tmp&0x1)==1 && rotAngle[index]!=0 ) return false;

				index++;

				tmp/=2;

			  }

		  }

		index=0;

		tmp=rotRC;

		rotVector = rotV;

		while( tmp!=0 )

		  {

			if( (tmp&0x1)==1 )

			  {

				rotAngle[index] = rotA*90;

				rotSpeed[index] = (int)(rotS/RubikWorld.hardwareSpeed);

				if( rotSpeed[index]<=0 && rotS>0 ) rotSpeed[index] = 1;

				if( rotSpeed[index]>=0 && rotS<0 ) rotSpeed[index] =-1;

				numRotations++;

			  }

			index++;

			tmp/=2;

		  }

    */

		return true;

	  }

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

// TODO

  private void setupPosition(String moves)

    {

    android.util.Log.e("object", "initializing: "+moves);

/*

    int index,tmp, a1,a2,a3, rv, rc, ra;

		numRotations=0;

		initializeVertices(mSize);

		int len=moves.length()/4;

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

		  {

			a1=moves.charAt(4*i+1)-'0';

			a2=moves.charAt(4*i+2)-'0';

			a3=moves.charAt(4*i+3)-'0';

			rv = (10*a1+a2)/32;

			rc = (10*a1+a2)%32;

			ra = 2-a3;

			rotVector = rv;

			tmp=rc;

			index=0;

			while( tmp!=0 )

			  {

				if( (tmp&0x1)==1 )

				  {

					rotAngle[index] = ra*90;

					RubikWorld.setIdentity(rotMat[index]);

					switch(rotVector)

					  {

					  case VECTX: RubikWorld.postRotate( rotMat[index], (float)((ra*90)%360), 1f,0f,0f); break;

					  case VECTY: RubikWorld.postRotate( rotMat[index], (float)((ra*90)%360), 0f,1f,0f); break;

					  case VECTZ: RubikWorld.postRotate( rotMat[index], (float)((ra*90)%360), 0f,0f,1f); break;

					  }

					transposeTiles(index);

					rotAngle[index]=0;

				  }

				tmp/=2;

				index++;

			  }

	  	}

 */

    }

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

      }

    mTexture.setTexture(bitmap);

    }

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

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

      {

      return mQuatAccumulated;

      }

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

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

    {

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

    }

    {

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

    }

    {

    boolean first = true;

    long effectID=0;

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

      {

        if( first )

          {

          first=false;

          effectID = mCubits[i].finishRotationNow(listener);

          }

        resetRotationAngle(mCubits[i].mRotationAngle);

        }

      }

    return effectID;

    }

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

  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;

    return true;

    }

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

      {

      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;

      }

    mRotationAngleStatic.set0(0.0f);

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

        mCubits[i].beginNewRotation(axis);

        }

     }

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

     long effectID=0;

     boolean first = true;

     mRotationAngleStatic.set0(0.0f);

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

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

         if( first )

           {

           first = false;

           effectID = mCubits[i].setUpCallback(listener);

           }

         }

     return effectID;

     }

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

  public void removeRotationNow()

     {

     boolean first = true;

     Static4D quat = null;

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

         if( first )

           {

           first = false;

         mCubits[i].removeRotationNow(quat);

         }

     mRotationAngleStatic.set0(0);

     }

  public boolean makeMove(String move)

    {

    int a1=move.charAt(1)-'0';

		int a2=move.charAt(2)-'0';

		int a3=move.charAt(3)-'0';

    int rotVector = (10*a1+a2)/32; // 0 --> VECTX, 1--> VECTY, 2 --> VECTZ

    int rotBitmap = (10*a1+a2)%32; // 01010 --> move the 2nd and 4th layer

    int rotAngle  = 2-a3;          // counterclockwise by rotAngle*90 degrees

		return scheduleMultiRotation(rotVector, rotBitmap, rotAngle);

    }

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

  public boolean backMove(String move)

    {

    int a1=move.charAt(1)-'0';

		int a2=move.charAt(2)-'0';

		int a3=move.charAt(3)-'0';

    int rotVector = (10*a1+a2)/32;

    int rotBitmap = (10*a1+a2)%32;

    int rotAngle  = a3-2;

		return scheduleMultiRotation(rotVector, rotBitmap, rotAngle);

    }

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

  public void initializeObject(String moves)

    {

    solve();

    setupPosition(moves);

    }

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

  public RubikObjectList getObjectList()

    {

    return mList;

    }

  abstract VertexEffectSink getSink(int size);

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