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.DistortedTexture;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.io.IOException;

import java.io.InputStream;

  public static final int COLOR_WHITE  = 0xffffffff;

  public static final int COLOR_BLUE   = 0xff0000ff;

  public static final int COLOR_GREEN  = 0xff00bb00;

  public static final int COLOR_RED    = 0xff990000;

  public static final int COLOR_ORANGE = 0xffff6200;

  public static final int COLOR_GREY   = 0xff727c7b;

  public static final int COLOR_VIOLET = 0xff7700bb;

  public static final int COLOR_BLACK  = 0xff000000;

  static final float SQ3 = (float)Math.sqrt(3);

  private static final float MAX_SIZE_CHANGE = 1.35f;

  final int NUM_CUTS;

  private static float mObjectScreenRatio = 1.0f;

  private static final float[] mTmp2 = new float[4];

  private final Static4D mQuat;

  private final int mNumLayers, mRealSize;

  private final ObjectList mList;

  private final DistortedEffects mEffects;

  private final VertexEffectRotate mRotateEffect;

  private final Dynamic1D mRotationAngle;

  private final Static3D mRotationAxis;

  private final Static3D mObjectScale;

  private final int[] mQuatDebug;

  DistortedTexture mTexture;

  MatrixEffectScale mScaleEffect;

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

    mRealSize = realSize;

    if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;

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

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    mNumTexRows = (NUM_TEXTURES+1)/NUM_STICKERS_IN_ROW;

    if( mNumTexCols*mNumTexRows < NUM_TEXTURES+1 ) mNumTexRows++;

      {

      mEffects.apply(vq);

      }

    double halfFOV = fov * (Math.PI/360);

    mCameraDist = 0.5f*NODE_RATIO / (float)Math.tan(halfFOV);

    setProjection( fov, 0.1f);

  private Static3D getPos(float[] origPos)

    {

    int len = origPos.length/3;

    float sumX = 0.0f;

    float sumY = 0.0f;

    float sumZ = 0.0f;

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

      {

      sumX += origPos[3*i  ];

      sumY += origPos[3*i+1];

      sumZ += origPos[3*i+2];

      }

    sumX /= len;

    sumY /= len;

    sumZ /= len;

    return new Static3D(sumX,sumY,sumZ);

    }

    if( mCreateFromDMesh )

      {

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

        {

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

      if( shouldResetTextureMaps() ) resetAllTextureMaps();

    else

      {

      MeshBase[] cubitMesh = new MeshBase[NUM_CUBITS];

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

        {

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

      mMesh = new MeshJoined(cubitMesh);

      resetAllTextureMaps();

      }

    }

  public void setObjectRatio(float sizeChange)

    {

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

    if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;

    }

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

  static float getObjectRatio()

    {

    int len = pos.length / 3;

    float axisY = axis.get1();

    float axisZ = axis.get2();

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

      {

      ret |= computeRow(pos[3*i]*axisX + pos[3*i+1]*axisY + pos[3*i+2]*axisZ);

      }

    return ret;

    }

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

    {

  private boolean wasRotateApplied()

    {

    return mEffects.exists(mRotateEffect.getID());

    }

// 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, CUBITS[j].computeAssociation(),index);

        }

      }

  int getCubitFaceColorIndex(int cubit, int face)

    {

    int x = (int)(texMap.get0()/texMap.get2());

    int y = (int)(texMap.get1()/texMap.get3());

    return (mNumTexRows-1-y)*NUM_STICKERS_IN_ROW + x;

// normal, not bandaged, object.

  int computeBitmapFromRow(int rowBitmap, int axis)

    {

    return rowBitmap;

    }

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

    float currError, minError = Float.MAX_VALUE;

    int minErrorIndex2 = -1;

    float x = pos[offset  ];

    float y = pos[offset+1];

    float z = pos[offset+2];

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

      {

        yo = mOrigPos[i][3*j+1];

        zo = mOrigPos[i][3*j+2];

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

        if( currError<minError )

          {

          minError = currError;

          minErrorIndex1 = i;

          minErrorIndex2 = j;

          }

      }

    pos[offset+1] = mOrigPos[minErrorIndex1][3*minErrorIndex2+1];

    pos[offset+2] = mOrigPos[minErrorIndex1][3*minErrorIndex2+2];

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

    int belongsToHowManyFaces = 0;

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

      {

    switch(belongsToHowManyFaces)

      {

               Static4D quat2 = QUATS[cubit.mQuatIndex];

               Static4D rotated1 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat1 );   // only check the first position

               rotated2.get(mTmp2, 0, 0, 0);

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

                 {

    }

// create StickerCoord and FaceTransform data structures

  void createFaceDataStructures()

    {

    int numCubitTypes = getNumCubitTypes(mNumLayers);

    FactoryCubit factory = FactoryCubit.getInstance();

    factory.clear();

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

      {

      double[][] vertices = getVertices(cubit);

      int[][] vertIndices = getVertIndexes(cubit);

      factory.createNewFaceTransform(vertices,vertIndices);

      factory.printFaceTransform();

      }

    factory.printStickerCoords();

    }

  public void createTexture()

    {

    Bitmap bitmap;

    Paint paint = new Paint();

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

    for(int row=0; row<mNumTexRows; row++)

      for(int col=0; col<mNumTexCols; col++)

        {

        if( tex>=NUM_TEXTURES ) break;

        createFaceTexture(canvas, paint, tex, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT);

        tex++;

        }

      {

      int max = DistortedLibrary.getMaxTextureSize();

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.log("failed to set texture of size "+bitmap.getWidth()+"x"+bitmap.getHeight()+" max is "+max);

      }

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

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

      {

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

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

    {

      {

        mMesh.setEffectAssociation(i, CUBITS[i].computeAssociation(),mQuatDebug[i]);

        }

      else

        {

        error = true;

      {

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

        {

        CUBITS[i].solve();

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

        }

      recordQuatsState("Failed to restorePreferences");

    }

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

  public void recordQuatsState(String message)

    {

    StringBuilder quats = new StringBuilder();

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

      {

      quats.append(mQuatDebug[j]);

      quats.append(" ");

      {

      }

    else

      {

      Exception ex = new Exception(message);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("quats" , quats.toString());

      crashlytics.setCustomKey("object", mList.name()+"_"+mNumLayers );

      crashlytics.recordException(ex);