Magic Cube

package org.distorted.objects;

import android.content.SharedPreferences;

import android.content.res.Resources;

import android.graphics.Bitmap;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.main.BuildConfig;

import org.distorted.main.RubikSurfaceView;

import java.io.DataInputStream;

import java.util.Random;

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

public abstract class TwistyObject extends DistortedNode

  {

  static final int COLOR_YELLOW = 0xffffff00;

  static final int COLOR_GREEN  = 0xff00bb00;

  static final int COLOR_RED    = 0xff990000;

  static final int COLOR_ORANGE = 0xffff6200;

  static final int COLOR_GREY   = 0xff727c7b;

  static final int COLOR_VIOLET = 0xff7700bb;

  static final int COLOR_BLACK  = 0xff000000;

  static final int TEXTURE_HEIGHT = 256;

  static final int NUM_STICKERS_IN_ROW = 4;

  static final float SQ2 = (float)Math.sqrt(2);

  static final float SQ5 = (float)Math.sqrt(5);

  static final float SQ6 = (float)Math.sqrt(6);

  private static final float NODE_RATIO = 1.40f;

  private static final float MIN_SIZE_CHANGE = 0.75f;

  private static final boolean mCreateFromDMesh = true;

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

  private static final int POST_ROTATION_MILLISEC = 500;

  final Static3D[] ROTATION_AXIS;

  final Static4D[] QUATS;

  final Cubit[] CUBITS;

  final int NUM_FACES;

  final int NUM_TEXTURES;

  final int NUM_CUBIT_FACES;

  final int NUM_AXIS;

  final int NUM_CUBITS;

  final float[] CUTS;

  private static float mInitScreenRatio;

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

  private final int mNodeSize;

  private final float[][] mOrigPos;

  private final Static3D mNodeScale;

  private final float mCameraDist;

  private int mNumTexRows, mNumTexCols;

  private int mRotRowBitmap;

  private int mRotAxis;

  private MeshBase mMesh;

  float[] mRowChances;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  MatrixEffectQuaternion mQuatEffect;

  TwistyObject(int numLayers, int realSize, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh,

               DistortedEffects nodeEffects, int[][] moves, ObjectList list, Resources res, int screenWidth)

    {

    super(nodeTexture,nodeEffects,nodeMesh);

    mNodeSize = screenWidth;

    resizeFBO(mNodeSize, (int)(NODE_RATIO*mNodeSize));

    mNumLayers = numLayers;

    mList = list;

    mOrigPos = getCubitPositions(mNumLayers);

    QUATS = getQuats();

    NUM_CUBITS  = mOrigPos.length;

    ROTATION_AXIS = getRotationAxis();

    NUM_AXIS = ROTATION_AXIS.length;

    mInitScreenRatio = getScreenRatio();

    NUM_FACES = getNumFaces();

    NUM_CUBIT_FACES = getNumCubitFaces();

    NUM_TEXTURES = getNumStickerTypes(mNumLayers)*NUM_FACES;

    CUTS = getCuts(mNumLayers);

    NUM_CUTS = CUTS== null ? 0: CUTS.length;

    mQuatDebug = new int[NUM_CUBITS];

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

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

    mQuat = quat;

    mRowChances = getRowChances(mNumLayers);

    mRotationAngle= new Dynamic1D();

    mRotateEffect = new VertexEffectRotate(mRotationAngle, mRotationAxis, CENTER);

    mRotationAngleStatic = new Static1D(0);

    float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;

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

    mScaleEffect = new MatrixEffectScale(mObjectScale);

    mQuatEffect  = new MatrixEffectQuaternion(quat, CENTER);

    nodeEffects.apply(nodeScaleEffect);

    mNumTexCols = NUM_STICKERS_IN_ROW;

    CUBITS = new Cubit[NUM_CUBITS];

    createMeshAndCubits(list,res);

    mTexture = new DistortedTexture();

    mEffects = new DistortedEffects();

    int num_quats = QUATS.length;

    for(int q=0; q<num_quats; q++)

      VertexEffectQuaternion vq = new VertexEffectQuaternion(QUATS[q],CENTER);

      vq.setMeshAssociation(0,q);

    mEffects.apply(mRotateEffect);

    mEffects.apply(mQuatEffect);

    mEffects.apply(mScaleEffect);

    // Now postprocessed effects (the glow when you solve an object) require component centers. In

    // order for the effect to be in front of the object, we need to set the center to be behind it.

    getMesh().setComponentCenter(0,0,0,-0.1f);

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

    setupPosition(moves);

    float fov = list.getFOV();

    }

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

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

  private void createMeshAndCubits(ObjectList list, Resources res)

    {

      int sizeIndex = ObjectList.getSizeIndex(list.ordinal(),mNumLayers);

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

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

        }

      }

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

        cubitMesh[i] = createCubitMesh(i,mNumLayers);

        Static3D pos = getPos(mOrigPos[i]);

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

        }

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

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;

    mObjectScale.set(scale,scale,scale);

    return mObjectScreenRatio*mInitScreenRatio;

    }

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

  int computeRow(float[] pos, int rotIndex)

    {

    int ret=0;

    Static3D axis = ROTATION_AXIS[rotIndex];

    float axisX = axis.get0();

  private int computeRow(float casted)

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

      {

      if( casted<CUTS[i] ) return (1<<i);

      }

    return (1<<NUM_CUTS);

    }

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

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

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

    {

    return (CUBITS[cubit].mRotationRow[axis] & rowBitmap) != 0;

    }

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

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

  private Static4D makeQuaternion(int axisIndex, int angleInDegrees)

    {

    Static3D axis = ROTATION_AXIS[axisIndex];

  private synchronized void setupPosition(int[][] moves)

    {

      int index, axis, rowBitmap, angle;

      int corr = (360/getBasicAngle());

            index = CUBITS[j].removeRotationNow(quat);

            }

    }

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

    Static4D texMap = mMesh.getTextureMap(NUM_FACES*cubit + face);

    }

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

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

  void clampPos(float[] pos, int offset)

    {

    int minErrorIndex1 = -1;

    float xo,yo,zo;

      int len = mOrigPos[i].length / 3;

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

        {

        xo = mOrigPos[i][3*j  ];

        }

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

    }

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

  boolean thereIsVisibleDifference(Cubit cubit, int quatIndex)

    {

    if ( cubit.mQuatIndex == quatIndex ) return false;

    int bitmap = (1<<(getNumLayers()-1)) + 1;

      if( (cubit.mRotationRow[i] & bitmap) != 0 ) belongsToHowManyFaces++;

      }

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

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

               float[] orig   = cubit.getOrigPosition();

               Static4D quat1 = QUATS[quatIndex];

               Static4D cubitCenter = new Static4D( orig[0], orig[1], orig[2], 0);              // not used for bandaged objects,

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

               rotated1.get(mTmp1, 0, 0, 0);

                 if( (computeRow(mTmp1,i) & computeRow(mTmp2,i) & bitmap) != 0 ) return false;

                 }

               return true;

      default: return true;  // edge or corner

      }

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

// the getFaceColors + final black in a grid (so that we do not exceed the maximum texture size)

    bitmap = Bitmap.createBitmap( mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmap);

    paint.setColor(COLOR_BLACK);

    canvas.drawRect(0, 0, mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, paint);

    int tex = 0;

    if( !mTexture.setTexture(bitmap) )

    }

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

  public int getNumLayers()

    {

    return mNumLayers;

    }

  public void continueRotation(float angleInDegrees)

    {

    mRotationAngleStatic.set0(angleInDegrees);

    }

  public Static4D getRotationQuat()

      return mQuat;

      }

  public void recomputeScaleFactor(int scrWidth)

    {

    mNodeScale.set(scrWidth,NODE_RATIO*scrWidth,scrWidth);

    }

  public void savePreferences(SharedPreferences.Editor editor)

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

    }

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

  public synchronized void restorePreferences(SharedPreferences preferences)

    {

    boolean error = false;

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

      mQuatDebug[i] = CUBITS[i].restorePreferences(preferences);

      if( mQuatDebug[i]>=0 && mQuatDebug[i]<QUATS.length)

        {

        CUBITS[i].modifyCurrentPosition(QUATS[mQuatDebug[i]]);

        }

      }

    if( error )

      }

      }

    if( BuildConfig.DEBUG )

      android.util.Log.e("quats" , quats.toString());

      android.util.Log.e("object", mList.name()+"_"+mNumLayers);

    }

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

    mMesh.markForDeletion();

    }

    mEffects.apply(effect, position);

    }