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.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

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

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

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

import org.distorted.library.type.Static4D;

import org.distorted.main.BuildConfig;

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

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

public abstract class TwistyObject extends DistortedNode

  {

  static final int COLOR_YELLOW = 0xffffff00;

  static final int COLOR_WHITE  = 0xffffffff;

  static final int COLOR_BLUE   = 0xff0000ff;

  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 SQ3 = (float)Math.sqrt(3);

  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 MAX_SIZE_CHANGE = 1.35f;

  private static final float MIN_SIZE_CHANGE = 0.75f;

  private static final boolean mCreateFromDMesh = false;

  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;

  final int NUM_CUTS;

  private static float mInitScreenRatio;

  private static float mObjectScreenRatio = 1.0f;

  private final int mNodeSize;

  private final Static3D[] mOrigPos;

  private final Static3D mNodeScale;

  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;

  private final float mCameraDist;

  private int mNumTexRows, mNumTexCols;

  private int mRotRowBitmap;

  private int mRotAxis;

  private MeshBase mMesh;

  float[] mRowChances;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  DistortedTexture mTexture;

  MatrixEffectScale mScaleEffect;

  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;

    mRealSize = realSize;

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

    mQuatDebug = new int[NUM_CUBITS];

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;

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

    mQuat = quat;

    mRowChances = getRowChances(mNumLayers);

    mRotationAngle= new Dynamic1D();

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

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

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    float scale  = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;

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

    mScaleEffect = new MatrixEffectScale(mObjectScale);

    mQuatEffect  = new MatrixEffectQuaternion(quat, CENTER);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    nodeEffects.apply(nodeScaleEffect);

    mNumTexCols = NUM_STICKERS_IN_ROW;

    mNumTexRows = (NUM_TEXTURES+1)/NUM_STICKERS_IN_ROW;

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

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

      }

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

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

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

    setProjection( fov, 0.1f);

    }

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

  private void createMeshAndCubits(ObjectList list, Resources res)

    {

    if( mCreateFromDMesh )

      {

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

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

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

        {

        CUBITS[i] = new Cubit(this,mOrigPos[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++)

        {

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

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

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

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

        }

      mMesh = new MeshJoined(cubitMesh);

      resetAllTextureMaps();

      }

    }

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

  public void setObjectRatio(float sizeChange)

    {

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

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;

    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;

    mObjectScale.set(scale,scale,scale);

    }

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

  static float getObjectRatio()

    {

    return mObjectScreenRatio*mInitScreenRatio;

    }

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

  int computeRow(float x, float y, float z, int rotIndex)

    {

    Static3D axis = ROTATION_AXIS[rotIndex];

    float tmp = x*axis.get0() + y*axis.get1() + z*axis.get2();

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

      {

      if( tmp<CUTS[i] ) return i;

      }

    return NUM_CUTS;

    }

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

  private boolean wasRotateApplied()

    {

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

    }

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

  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

// 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 synchronized void setupPosition(int[][] moves)

    {

    if( moves!=null )

      {

      Static4D quat;

      int index, 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) )

            {

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

            mMesh.setEffectAssociation(j, CUBITS[j].computeAssociation(),index);

            }

        }

      }

    }

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

  int getCubitFaceColorIndex(int cubit, int face)

    {

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

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

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

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

    }

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

// 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 grid (so that we do not exceed the maximum texture size)

  public void createTexture()

    {

    Bitmap bitmap;

    Paint paint = new Paint();

    bitmap = Bitmap.createBitmap( mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*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(COLOR_BLACK);

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

    int tex = 0;

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

        }

    if( !mTexture.setTexture(bitmap) )

      {

      int max = DistortedLibrary.getMaxTextureSize();

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

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

      }

    }

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

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

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

        }

      else

        {

        error = true;

        }

      }

    if( error )

      {

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

      }

    if( BuildConfig.DEBUG )

      {

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

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

      }

    else

      {

      Exception ex = new Exception(message);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

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

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

      crashlytics.recordException(ex);

      }

    }

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

  public void releaseResources()

    {

    mTexture.markForDeletion();

    mMesh.markForDeletion();

    mEffects.markForDeletion();

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

      {

      CUBITS[j].releaseResources();

      }

    }

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

  public void apply(Effect effect, int position)

    {

    mEffects.apply(effect, position);

    }

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

  public void remove(long effectID)

    {

    mEffects.abortById(effectID);

    }

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

  public synchronized void solve()

    {

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

      {

      CUBITS[i].solve();

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

      }

    }

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

  public void resetAllTextureMaps()

    {

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

    int color, row, col;

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

        row = (mNumTexRows-1) - color/mNumTexCols;

        col = color%mNumTexCols;

        maps[cubitface] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);

        }

      mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);

      }

    }

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

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

    {

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

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

    int row = (mNumTexRows-1) - newColor/mNumTexCols;

    int col = newColor%mNumTexCols;

    maps[face] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);

    mMesh.setTextureMap(maps,NUM_CUBIT_FACES*cubit);

    }

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

  public synchronized 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>=mNumLayers )

      {

      android.util.Log.e("object", "invalid rotation row: "+row);

      return;

      }

    mRotAxis     = axis;

    mRotRowBitmap= (1<<row);

    mRotationAngleStatic.set0(0.0f);

    mRotationAxis.set( ROTATION_AXIS[axis] );

    mRotationAngle.add(mRotationAngleStatic);

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

    }

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

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

    {

    if( wasRotateApplied() )

      {

      mRotAxis     = axis;

      mRotRowBitmap= rowBitmap;

      mRotationAngleStatic.set0(0.0f);

      mRotationAxis.set( ROTATION_AXIS[axis] );

      mRotationAngle.setDuration(durationMillis);

      mRotationAngle.resetToBeginning();

      mRotationAngle.add(new Static1D(0));

      mRotationAngle.add(new Static1D(angle));

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

      mRotateEffect.notifyWhenFinished(listener);

      return mRotateEffect.getID();

      }

    return 0;

    }

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

  public long finishRotationNow(EffectListener listener, int nearestAngleInDegrees)

    {

    if( wasRotateApplied() )

      {

      float angle = getAngle();

      mRotationAngleStatic.set0(angle);

      mRotationAngleFinal.set0(nearestAngleInDegrees);

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

      mRotationAngle.setDuration(POST_ROTATION_MILLISEC);

      mRotationAngle.resetToBeginning();

      mRotationAngle.removeAll();

      mRotationAngle.add(mRotationAngleStatic);

      mRotationAngle.add(mRotationAngleMiddle);

      mRotationAngle.add(mRotationAngleFinal);

      mRotateEffect.notifyWhenFinished(listener);

      return mRotateEffect.getID();

      }

    return 0;

    }

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

  private float getAngle()

    {

    int pointNum = mRotationAngle.getNumPoints();

    if( pointNum>=1 )

      {

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

      }

    else

      {

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.log("points in RotationAngle: "+pointNum);

      return 0;

      }

    }

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

  public synchronized void removeRotationNow()

    {

    float angle = getAngle();

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

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

    mRotationAngle.removeAll();

    mRotationAngleStatic.set0(0);

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

      if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

        {

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

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

        }

    }

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

  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 = CUBITS[i].getDistSquared(point3D);

      if( dist<minDist )

        {

        minDist = dist;

        currentBest = i;

        }

      }

    return currentBest;

    }

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

  public int computeNearestAngle(float angle, float speed)

    {

    final int NEAREST = 360/getBasicAngle();

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

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

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

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

    }

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

  public float getCameraDist()

    {

    return mCameraDist;

    }

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

  public int getNodeSize()

    {

    return mNodeSize;

    }

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

  public ObjectList getObjectList()

    {

    return mList;

    }

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

  abstract float getScreenRatio();

  abstract Static3D[] getCubitPositions(int numLayers);

  abstract Static4D[] getQuats();

  abstract int getNumFaces();

  abstract int getNumStickerTypes(int numLayers);

  abstract int getNumCubitFaces();

  abstract MeshBase createCubitMesh(int cubit, int numLayers);

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

  abstract int getFaceColor(int cubit, int cubitface, int numLayers);

  abstract float returnMultiplier();

  abstract float[] getRowChances(int numLayers);

  abstract float[] getCuts(int numLayers);

  abstract boolean shouldResetTextureMaps();

  public abstract boolean isSolved();

  public abstract Static3D[] getRotationAxis();

  public abstract int getBasicAngle();

  public abstract String retObjectString();

  public abstract int randomizeNewRotAxis(Random rnd, int oldRotAxis);

  public abstract int randomizeNewRow(Random rnd, int oldRotAxis, int oldRow, int newRotAxis);

  public abstract int getObjectName(int numLayers);

  public abstract int getInventor(int numLayers);

  public abstract int getComplexity(int numLayers);

  }