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.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 java.io.DataInputStream;

import java.util.Random;

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

public abstract class RubikObject extends DistortedNode

  {

  private static final float NODE_RATIO = 1.32f;

  private static boolean mCreateFromDMesh = true;

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

  static final int INTERIOR_COLOR = 0xff000000;

  private static final int POST_ROTATION_MILLISEC = 500;

  private static final int TEXTURE_HEIGHT = 256;

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

  private static float mInitScreenRatio;

  private final int mNodeSize;

  private int mRotRowBitmap;

  private int mRotAxis;

  private Static3D[] mOrigPos;

  private Static3D mNodeScale;

  private Static4D mQuat;

  private int mSize;

  private RubikObjectList mList;

  private MeshBase mMesh;

  private VertexEffectRotate mRotateEffect;

  private Static3D mObjectScale;

  float mStart, mStep;

  float[] mRowChances;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  MatrixEffectQuaternion mQuatEffect;

  RubikObject(int size, int fov, Static4D quat, DistortedTexture nodeTexture, MeshSquare nodeMesh,

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

    {

    super(nodeTexture,nodeEffects,nodeMesh);

    mNodeSize = screenWidth;

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

    mList = list;

    mOrigPos = getCubitPositions(size);

    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()*NUM_FACES;

    BASIC_STEP = getBasicStep();

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    mSize = size;

    computeStartAndStep(mOrigPos);

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

    mQuat = quat;

    mRowChances = getRowChances();

    mRotationAngle= new Dynamic1D();

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

    mRotationAngleStatic = new Static1D(0);

    float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mSize;

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

    mScaleEffect = new MatrixEffectScale(mObjectScale);

    mQuatEffect  = new MatrixEffectQuaternion(quat, CENTER);

    nodeEffects.apply(nodeScaleEffect);

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

    setProjection(fov, 0.1f);

    }

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

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

        }

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

        cubitMesh[i] = createCubitMesh(i);

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

        }

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

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mSize;

    mObjectScale.set(scale,scale,scale);

    return mObjectScreenRatio*mInitScreenRatio;

    }

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

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

    mStep  = (max-min+BASIC_STEP)/mSize;

    }

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

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

    {

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

    return ((1<<cubitRow)&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);

            }

    }

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

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

    return diff*diff < MAX_ERROR;

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

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

    }

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

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

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

    Canvas canvas = new Canvas(bitmap);

    paint.setColor(INTERIOR_COLOR);

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

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

      {

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

      }

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

  public int getSize()

    {

    return mSize;

    }

  public void continueRotation(float angleInDegrees)

    {

    mRotationAngleStatic.set0(angleInDegrees);

    }

  public Static4D getRotationQuat()

      return mQuat;

      }

  public void recomputeScaleFactor(int scrWidth, int scrHeight)

    {

    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)

    {

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

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

      }

    }

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

    mEffects.apply(effect, position);

    }

    mEffects.abortById(effectID);

    }

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

  public synchronized void solve()

    {

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

      CUBITS[i].solve();

      }

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

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

    int color;

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

      {

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

      for(int cubitface=0; cubitface<NUM_CUBIT_FACES; cubitface++)

        {

        color = getFaceColor(cubit,cubitface,mSize);

        }

      mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);

      }

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

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

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

    mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);

    }

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

  public synchronized void beginNewRotation(int axis, int row )

    {

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

    mRotAxis     = axis;

    mRotationAngleStatic.set0(0.0f);

    mRotationAxis.set( ROTATION_AXIS[axis] );

    mRotateEffect.setMeshAssociation( mRotRowBitmap<<(axis*RubikObjectList.MAX_OBJECT_SIZE) , -1);

    }

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

    {

    mRotationAngleStatic.set0(0.0f);

    mRotateEffect.setMeshAssociation( mRotRowBitmap<<(axis*RubikObjectList.MAX_OBJECT_SIZE) , -1);

    mRotateEffect.notifyWhenFinished(listener);

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

  public long finishRotationNow(EffectListener listener, int nearestAngleInDegrees)

    {

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

  private float getAngle()

    {

    int pointNum = mRotationAngle.getNumPoints();

    if( pointNum>=1 )

      {

      return mRotationAngle.getPoint(pointNum-1).get0();

      }

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

  public synchronized void removeRotationNow()

    {

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

        }

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

  public void initializeObject(int[][] moves)

    {

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

    float dist, minDist = Float.MAX_VALUE;

    int currentBest=-1;

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

      if( dist<minDist )

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

  public int computeNearestAngle(float angle, float speed)

    {

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

    if( tmp!=0 ) return NEAREST*tmp;

    return speed> 1.2f ? NEAREST*(angle>0 ? 1:-1) : 0;

    }

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